第十三天 面向对象-final static 匿名对象内部类包代码块【悟空教程】

第13天 面向对象

第1章 面向对象其他知识点

1.1 final与static关键字

1.1.1 final关键字

1.1.1.1 final概念

继承的出现提高了代码的复用性,并方便开发。但随之也有问题,有些类在描述完之后,不想被继承,或者有些类中的部分方法功能是固定的,不想让子类重写。可是当子类继承了这些特殊类之后,就可以对其中的方法进行重写,那怎么解决呢?

要解决上述的这些问题,需要使用到一个关键字final,final的意思为最终,不可变。final是个修饰符,它可以用来修饰类,类的成员,以及局部变量。

1.1.1.2 final的特点

  • final修饰类不可以被继承,但是可以继承其他类。

class Yy {}

final class Fu extends Yy{} //可以继承Yy

class Zi extends Fu{} //不能继承Fu

  • final修饰的方法不可以被覆盖,但父类中没有被final修饰方法,子类覆盖后可以加final。

class Fu {

// final修饰的方法,不可以被覆盖,但可以继承使用

public final void method1(){}

public void method2(){}

}

class Zi extends Fu {

//重写method2方法

public final void method2(){}

}

  • final修饰的变量称为常量,这些变量只能赋值一次。

final int i = 20;

i = 30; //赋值报错,final修饰的变量只能赋值一次

  • 引用类型的变量值为对象地址值,地址值不能更改,但是地址内的对象属性值可以修改。

final Person p = new Person();

Person p2 = new Person();

p = p2; //final修饰的变量p,所记录的地址值不能改变

p.name = "小明";//可以更改p对象中name属性值

p不能为别的对象,而p对象中的name或age属性值可更改。

  • 修饰成员变量,需要在创建对象前赋值,否则报错。(当没有显式赋值时,多个构造方法的均需要为其赋值。)

class Demo {

//直接赋值

final int m = 100;

//final修饰的成员变量,需要在创建对象前赋值,否则报错。

final int n;

public Demo(){

//可以在创建对象时所调用的构造方法中,为变量n赋值

n = 2016;

}

}

1.1.1.3 final注意事项

  • 引用类型的变量值为对象地址值,地址值不能更改,但是地址内内容可以修改。

如:

final Person p = new Person();

p不能为别的对象,而p对象中的name或age可更改。

  • 修饰成员变量,需要在创建对象前赋值,否则报错。(当没有显式赋值时,多个构造方法的均需要为其赋值。)

//final修饰类不能继承

public /*final*/ class Person {

//修饰成员变量,需要在创建对象前赋值,否则报错

private final String name;

//需要在创建对象前赋值

public Person(){

this.name = "";

}

//用带参构造方法为name赋值

public Person(String name){

this.name = name;

}

//final修饰的方法不能被重写

public /* final*/ void method(){

System.out.println("父类方法");

}

public String getName() {

return name;

}

//public void setName(String name) {

//final修饰的变量不能2次赋值

//this.name = name;

//}

}

public class Student extends Person{

@Override

public void method(){

System.out.println("子类方法");

}

}

/*

* final 最终修饰符

*

* 修饰类代表类不能被继承

* 修饰方法不能被重写

* 修饰变量 不能被二次赋值,是 常量

*/

public class Test {

public static void main(String[] args) {

//修饰变量 不能被二次赋值,是 常量

//final int a = 10;

final double PI = 3.141592653589;

System.out.println(PI*2);

final Person p = new Person();//0x1111

//p.setName("柳岩");

//p.setName("金莲");

System.out.println(p.getName());

//引用类型的变量值为对象地址值,地址值不能更改,但是地址内内容可以修改。

//p = new Person();//0x1234

}

}

1.1.2 static关键字

1.1.2.1 static概念与功能;

当在定义类的时候,类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时,这个方法没有访问到对象的特有数据时,方法创建这个对象有些多余。可是不创建对象,方法又调用不了,这时就会想,那么我们能不能不创建对象,就可以调用方法呢?

可以的,我们可以通过static关键字来实现。static是静态修饰符,一般修饰成员。被static修饰的成员属于类,不属于单个这个类的某个对象。

被static修饰的成员可以并且建议通过类名直接访问。也可以通过某个对象访问到属于类的静态成员,多个对象共享使用同一个静态成员。

1.1.2.2 static特点:

static是静态修饰符,一般修饰成员。被static修饰的成员属于类,不属于单个这个类的某个对象。

static修饰的成员被多个对象共享。

static修饰的成员属于类,但是会影响每一个对象。

被static修饰的成员又叫类成员,不叫对象的成员。

如下例中国籍变量,所有中国人国籍均应该为中国,不应各自定义各自的国籍,所以可以将国籍定义为static,属于类,被多个对象共享。

1.1.2.3 static注意事项

  • 静态内容是优先于对象存在,只能访问静态,不能使用this/super。静态修饰的内容存于静态区。
  • 同一个类中,静态成员只能访问静态成员
  • main方法为静态方法仅仅为程序入口,不属于任何一个对象,所以可以定义在任意类中。

1.1.2.4 static修饰后成员的使用

被static修饰的成员可以并且建议通过类名直接访问。也可以通过某个对象访到属于类的静态成员,原因即多个对象均属于一个类,共享使用同一个静态成员。

格式:

类名.静态成员变量名

类名.静态成员方法名(参数)

对象名.静态成员变量名 ------不建议,出现警告

对象名.静态成员方法名(参数) ------不建议,出现警告

代码演示:

class Demo {

//静态成员变量

public static int num = 100;

//静态方法

public static void method(){

System.out.println("静态方法");

}

}

class Test {

public static void main(String[] args) {

System.out.println(Demo.num);

Demo.method();

}

}

1.1.3 static与final连用定义静态常量

通常使用public static final来修饰某个类中的静态常量。此时标识符用全部大写,多个单词使用下划线连接。

格式: 类名.静态成员变量名

如:

定义包含静态成员的的类。

public class Company{

public static final String COMPANY_NAME = “顺风通不通快递公司”;

public static void method(){

System.out.println(“一个静态方法”);

}

}

使用类的静态成员不需要创建对象,直接使用类名即可。

System.out.println(Company. companyName); //打印顺风通不通快递公司

Company.method(); //调用一个静态方法

接口中的每个成员变量都默认使用public static final修饰,所有接口中的成员变量都是静态常量,由于接口没有构造方法,所以必须显示赋值。可以直接用接口名访问。

/*

* 被static修饰的成员属于类,不属于单个这个类的某个对象。

*/

public class Person {

static int age;

private String name;

//ctrl+shift+x,y大小写切换

public static final String ADDRESS ="中国";

// 静态内容是优先于对象存在,只能访问静态,不能使用this/super。静态修饰的内容存于静态区。

public static void method(){

//System.out.println(ADDRESS);

System.out.println("我是一个静态方法");

System.out.println(age);

//不能使用this/super

//System.out.println(this.age);

//静态只能访问静态 不能用已存在的去访问还没出现的 静态内容优于对象存在

//System.out.println(name);

}

//main方法为静态方法仅仅为程序入口,不属于任何一个对象,所以可以定义在任意类中。

public static void main(String[] args){

method();

}

}

/*

* static静态修饰符

*

* 格式:

* 类名.静态成员变量名

* 类名.静态成员方法名(参数)

* 对象名.静态成员变量名 ------不建议,出现警告

* 对象名.静态成员方法名(参数) ------不建议,出现警告

*/

public class Test {

public static void main(String[] args) {

// System.out.println(Person.age);

//

// Person.method();

Person p = new Person();

p.age = 18;

System.out.println(p.age);

Person p2 = new Person();

System.out.println(p2.age);

System.out.println(Person.ADDRESS);

}

}

1.2 匿名对象

1.2.1 匿名对象的概念

匿名对象是指创建对象时,只有创建对象的语句,却没有把对象地址值赋值给某个变量。

如:已经存在的类:

public class Person{

public void eat(){

System.out.println();

}

}

创建一个普通对象

Person p = new Person();

创建一个匿名对象

new Person();

1.2.2 匿名对象的特点

  • 创建匿名对象直接使用,没有变量名。

new Person().eat() //eat方法被一个没有名字的Person对象调用了。

  • 匿名对象在没有指定其引用变量时,只能使用一次。

new Person().eat(); 创建一个匿名对象,调用eat方法

new Person().eat(); 想再次调用eat方法,重新创建了一个匿名对象

  • 匿名对象可以作为方法接收的参数、方法返回值使用(使用可以在任意位置)

class Demo {

public static Person getPerson(){

//普通方式

//Person p = new Person();

//return p;

//匿名对象作为方法返回值

return new Person();

}

public static void method(Person p){}

}

class Test {

public static void main(String[] args) {

//调用getPerson方法,得到一个Person对象

Person person = Demo.getPerson();

//调用method方法

Demo.method(person);

//匿名对象作为方法接收的参数

Demo.method(new Person());

}

}

1.3 内部类

1.3.1 内部类概念

  • 什么是内部类

将类写在其他类的内部,可以写在其他类的成员位置和局部位置,这时写在其他类内部的类就称为内部类。其他类也称为外部类。

  • 什么时候使用内部类

在描述事物时,若一个事物内部还包含其他可能包含的事物,比如在描述汽车时,汽车中还包含这发动机,这时发动机就可以使用内部类来描述。

class 汽车 { //外部类

class 发动机 { //内部类

}

}

  • 内部类的分类

内部类分为成员内部类与局部内部类。

我们定义内部类时,就是一个正常定义类的过程,同样包含各种修饰符、继承与实现关系等。在内部类中可以直接访问外部类的所有成员。

1.3.2 成员内部类

成员内部类,定义在外部类中的成员位置。与类中的成员变量相似,可通过外部类对象进行访问

  • 定义格式

class 外部类 {

修饰符 class 内部类 {

//其他代码

}

}

  • 访问方式

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

  • 成员内部类代码演示
    • 定义类

class Body {//外部类,身体

private boolean life= true; //生命状态

public class Heart { //内部类,心脏

public void jump() {

System.out.println("心脏噗通噗通的跳")

System.out.println("生命状态" + life); //访问外部类成员变量

}

}

}

  • 访问内部类

public static void main(String[] args) {

//创建内部类对象

Body.Heart bh = new Body().new Heart();

//调用内部类中的方法

bh.jump();

}

1.3.3 局部内部类

局部内部类,定义在外部类方法中的局部位置。与访问方法中的局部变量相似,可通过调用方法进行访问

  • 定义格式

class 外部类 {

修饰符 返回值类型 方法名(参数) {

class 内部类 {

//其他代码

}

}

}

  • 访问方式

在外部类方法中,创建内部类对象,进行访问

  • 局部内部类代码演示
    • 定义类

class Party {//外部类,聚会

public void puffBall(){// 吹气球方法

class Ball {// 内部类,气球

public void puff(){

System.out.println("气球膨胀了");

}

}

//创建内部类对象,调用puff方法

new Ball().puff();

}

}

  • 访问内部类

public static void main(String[] args) {

//创建外部类对象

Party p = new Party();

//调用外部类中的puffBall方法

p.puffBall();

}

/*

* 内部类

* 内部类分成员内部类和局部内部类

*/

public class Outer {

private String name = "外部名字";

/*

* 成员内部类

*/

class Inner{

public void method(){

System.out.println(name);

}

}

public void outMethod(){

/*

* 局部内部类

*/

class Inner2{

public void method(){

System.out.println(name);

}

}

//创建局部内部类对象

Inner2 in = new Inner2();

in.method();

}

}

/*

* 测试成员内部类创建对象

*/

public class Test {

public static void main(String[] args) {

//创建成员内部类对象

Outer.Inner in = new Outer().new Inner();

//调用成员内部类方法

in.method();

System.out.println("-----------");

Outer out = new Outer();

out.outMethod();

}

}

1.3.4 内部类的实际使用——匿名内部类

1.3.4.1 匿名内部类概念

内部类是为了应对更为复杂的类间关系。我们在完成计算机语言相对底层的位置才会涉及,日常业务中很难遇到,这里不做赘述。

最常用到的内部类就是匿名内部类,是局部内部类的一种。

匿名内部类有两个步骤:

  • 临时定义一个类型的子类
  • 定义后即刻创建刚刚定义的这个类的对象

1.3.4.2 匿名内部类作用与格式

作用:匿名内部类是创建某个类型子类对象的快捷方式。

格式:

new 父类或接口(){

//进行方法重写

};

代码演示

//已经存在的父类:

public abstract class Person{

public abstract void eat();

}

//定义并创建该父类的子类对象,并用多态的方式赋值给父类引用变量

Person p = new Person(){

public void eat() {

System.out.println(“我吃了”);

}

};

//调用eat方法

p.eat();

使用匿名对象的方式,将定义子类与创建子类对象两个步骤由一个格式一次完成,。虽然是两个步骤,但是两个步骤是连在一起完成的。

匿名内部类如果不定义变量引用,则也是匿名对象。代码如下:

new Person(){

public void eat() {

System.out.println(“我吃了”);

}

}.eat();

/*

* 定义Fly接口

*/

public interface Fly {

public abstract void open();

public abstract void fly();

public abstract void close();

}

public class YanZi implements Fly{

@Override

public void open() {

System.out.println("张开小翅膀");

}

@Override

public void fly() {

System.out.println("能飞3000米高空");

}

@Override

public void close() {

System.out.println("关闭小翅膀,安全着陆");

}

//一个类中可以定义多个类,但只能有一个类public的

class Person(){

}

}

/*

* 匿名内部类

*

* new 父类/接口(){

* //重写需要重写的方法

* };

*/

public class Test {

public static void main(String[] args) {

Fly yz = new YanZi();

yz.open();

yz.fly();

yz.close();

new YanZi().open();

System.out.println("-------------------");

//实现类对象赋值给父接口

Fly fj = new Fly(){

@Override

public void open() {

System.out.println("不需要张开翅膀,一直都是张开状态");

}

@Override

public void fly() {

System.out.println("喷气式助力飞行!");

}

@Override

public void close() {

System.out.println("不需要关闭翅膀,得哪撞哪");

}

};

fj.open();

fj.fly();

fj.close();

System.out.println("-----------------------------");

//实现类对象直接以匿名对象的方式调用方法

new Fly() {

@Override

public void open() {

System.out.println("小翅膀");

}

@Override

public void fly() {

System.out.println("乱飞");

}

@Override

public void close() {

System.out.println("各种撞树");

}

}.fly();

}

}

1.4

1.4.1 包的概念

java的包,其实就是我们电脑系统中的文件夹,包里存放的是程序生成的.class文件。

当.class文件很多的时候,通常我们会采用多个包进行存放管理他们,这种方式称为分包管理,分包管理是组织软件项目结构的基本方式。

在项目中,我们将相同功能的类放到一个包中,方便管理。并且日常项目的分工也是以包作为边界。

类中声明的包必须与实际class文件所在的文件夹情况相一致,即类声明在a包下,则生成的.class文件必须在a文件夹下,否则,程序运行时会找不到类。

1.4.2 包的定义格式

通常使用公司网址反写,可以有多层包,包名采用全部小写字母,多层包之间用”.”连接

类中包的声明格式:

package 包名.包名.包名…;

如:Java帮帮官网网址javahelp.com.cn那么网址反写就为cn.com.javahelp

  • 注意:声明包的语句,必须写在程序有效代码的第一行(注释不算)
  • 代码演示:

package cn.com.javahelp; //包的声明,必须在有效代码的第一行

import java.util.Scanner;

import java.util.Random;

public class Demo {}

1.4.3 包的访问

在访问类时,为了能够找到该类,必须使用含有包名的类全名(包名.类名)。

包名.包名….类名

如: java.util.Scanner

java.util.Random

cn.com.javahelp.Demo

带有包的类,创建对象格式:包名.类名 变量名 = new包名.类名();

cn.com.javahelp.Demo d = new cn.com.javahelp.Demo();

  • 前提:包的访问与访问权限密切相关,这里以一般情况来说,即类用public修饰的情况。
  • 类的简化访问

当我们要使用一个类时,这个类与当前程序在同一个包中(即同一个文件夹中),或者这个类是java.lang包中的类时通常可以省略掉包名,直接使用该类。

如:cn.itcast包中有两个类,PersonTest类,与Person类。我们在PersonTest类中,访问Person类时,由于是同一个包下,访问时可以省略包名,即直接通过类名访问 Person。

类名 变量名 = new类名();

Person p = new Person();

  • 当我们要使用的类,与当前程序不在同一个包中(即不同文件夹中),要访问的类必须用public修饰才可访问。

package cn.com.javahelp02;

public class Person {}

/*

* 用public修饰的类 可以在其他包中访问 使用默认权限修饰的类 只能在本包下访问 其他包无法访问

*/

public class Tree {

public void chengLiang(){

System.out.println("可以乘凉");

}

}

import cn.com.javahelp.Person;

public class Test {

public static void main(String[] args) {

//在访问类时,为了能够找到该类,使用类时,应该使用 包含 包 的类全名。

// cn.itcast.Person p = new cn.itcast.Person();

// p.eat();

// cn.itcast6.Tree t = new cn.itcast6.Tree();

//当在同一个文件夹下不需要使用类全名

// Tree t = new Tree();

// t.chengLiang();

//因为String在java.lang包下 所以不需要使用类全名不需要导包

// String s = "";

//当被使用的类与使用的类不在同一个文件夹下时,

//被使用者必须用public修饰才可被其他包下的类访问,

//我们可以通过导包的方式使用该类,避免使用类全名

Person p = new Person();

//当多个文件夹下有相同的类名时,只能有一个导包使用,其他必须仍然书写全名。

cn.itcast2.Person p2 = new cn.itcast2.Person();

}

}

1.4.4 import导包

我们每次使用类时,都需要写很长的包名。很麻烦,我们可以通过import导包的方式来简化。

可以通过导包的方式使用该类,可以避免使用全类名编写(即,包类.类名)。

导包的格式:

import 包名.类名;

当程序导入指定的包后,使用类时,就可以简化了。演示如下

//导入包前的方式

//创建对象

java.util.Random r1 = new java.util.Random();

java.util.Random r2 = new java.util.Random();

java.util.Scanner sc1 = new java.util.Scanner(System.in);

java.util.Scanner sc2 = new java.util.Scanner(System.in);

//导入包后的方式

import java.util.Random;

import java.util.Scanner;

//创建对象

Random r1 = new Random();

Random r2 = new Random();

Scanner sc1 = new Scanner(System.in);

Scanner sc2 = new Scanner(System.in);

  • import导包代码书写的位置:在声明包package后,定义所有类class前,使用导包import包名.包名.类名;

1.4.5 访问权限

在Java中提供了四种访问权限,使用不同的访问权限时,被修饰的内容会有不同的访问权限,以下表来说明不同权限的访问能力:

public

protected受保护的

default默认

private私有的

同一类中

同一包中(子类与无关类)

不同包的子类

不同包中的无关类

所以,在日常开发过程中,如果允许其他包的类访问使用public,如果仅允许其他包的子类访问使用protected,仅本包内的类访问使用默认,仅能本类中访问使用private。

/*

* 访问权限修饰符

*/

public class Person {

public void method1(){

System.out.println("公共方法");

}

protected void method2(){

System.out.println("受保护的方法(为了给子类使用)");

}

void method3(){

System.out.println("默认权限方法");

}

private void method4(){

System.out.println("私有方法");

}

//同一个类中

public void test(){

method1();

method2();

method3();

method4();

}

}

/*

*四种方法都可以执行

*/

public class Test {

public static void main(String[] args) {

Person p = new Person();

p.test();

}

}

/*

* 同一个包下 子类 或者无关类

*/

public class Student {

public void test(){

Person p = new Person();

p.method1();

p.method2();

p.method3();

// p.method4();

}

}

import cn.itcast7.Person;

/*

* 不同包下的子类

*/

public class Student extends Person{

public void test(){

method1();

method2();

// method3();

// method4();

}

}

import cn.com.javahelp.Person;

/*

* 不同包下的无关类

*/

public class Test {

public static void main(String[] args) {

Person p = new Person();

p.method1();

// p.method2();

// p.method3();

// p.method4();

}

}

归纳一下:在日常开发过程中,编写的类、方法、成员变量的访问

  • 要想仅能在本类中访问使用private修饰;
  • 要想本包中的类都可以访问不加修饰符即可;
  • 要想本包中的类与其他包中的子类可以访问使用protected修饰
  • 要想所有包中的所有类都可以访问使用public修饰。
  • 注意:如果类用public修饰,则类名必须与文件名相同。一个文件中只能有一个public修饰的类。

1.4.6 项目分层(分包)

一个项目随着功能的增加、继承树的扩展会出现众多的Java类。这时,不仅需要将一个类中的整体功能抽取出成为独立方法,还需要将功能边界即功能所有者界定,而这就是定义类与包的过程。在定义好不同的类之后,再将相似功能的类放到同一个包中进行统一管理。

1.5 代码块

1.5.1 局部代码块

普通代码块就是直接定义在方法或语句中,以”{}”划定的代码区域,此时只需要关注作用域的不同即可,方法和类都是以代码块的方式划定边界的,如:

class Demo{

public static void main(String[] args) {

{

int x = 1;

System.out.println("普通代码块" + x);

}

int x = 99;

System.out.println("代码块之外" + x);

}

}

结果:

普通代码块1

代码块之外99

1.5.2 构造代码块

直接定义在类中成员位置的代码块,优先于构造方法执行,构造代码块用于执行所有对象均需要的初始化动作,每创建一个对象均会执行一次构造代码块。

public class Person {

private String name;

private int age;

static{

System.out.println("静态代码块执行了");

}

{

System.out.println("构造代码块执行了");

}

Person(){

System.out.println("Person无参数的构造函数执行");

}

Person(int age){

this.age = age;

System.out.println("Person(age)参数的构造函数执行");

}

}

class PersonDemo{

public static void main(String[] args) {

Person p = new Person();

Person p1 = new Person(23);

}

}

1.5.3 静态代码块

静态代码块是定义在成员位置,使用static修饰的代码块。

特点:

  • 它优先于主方法执行、优先于构造代码块执行,当以任意形式第一次使用到该类时执行。
  • 该类不管创建多少对象,静态代码块只执行一次。
  • 可用于给静态变量赋值,用来给类进行初始化。

public class Person {

private String name;

private int age;

//静态代码块

static{

System.out.println("静态代码块执行了");

}

}

public class Person {

private String name;

//成员代码块 又叫构造代码块 对象级别的代码块,每次创建对象都会执行一次

{

System.out.println("我是构造代码块");

}

//静态代码块 类级别的代码块,只有第一次创建对象时才运行,之后创建对象就不执行了

static{

System.out.println("静态代码块");

}

public Person(String name) {

super();

this.name = name;

}

public Person() {

super();

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

}

public class Test {

public static void main(String[] args) {

int a = 10;

//局部代码块限定变量作用域范围

{

System.out.println(a);

int b = 20;

System.out.println(b);

}

// System.out.println(b);

Person p = new Person();

Person p2 = new Person("刘备");

Person p3 = new Person("刘备");

Person p4 = new Person("刘备");

Person p5 = new Person("刘备");

}

}

第2章 本日学习作业

2.1 知识点相关题:

2.1.1 定义Person对象,包含String name ,int age ,String addr成员属性和满参构造方法,创建show方法展示该对象的名字,年龄和家庭住址

1) 使用匿名方法创建对象传参并调用show方法,并在控制台打印

2.1.2 匿名内部类 补全代码

interface Inter{void show();}class Outer{//补全代码}class OuterDemo{public static void main(String[] args) {Outer.method().show();//HelloWorld}

答案:public static Inter method(){

return new Inter(){

@Override

public void show() {

System.out.println("HelloWorld");

}

};

}

2.1.3 static 方法与普通方法有什么区别?

static 方法在内存中只有一份,普通方法在每个被调用中维持一份拷贝,static方法属于类方法随着类的加载而加载!普通方法属于对象随着对象的创建而存在随着对象的消失而消失。

2.1.4 是否可以在static环境中访问非static变量?

答:static变量在java中是属于类的,它在所有实例中的值都是一样的。当java虚拟机载入的时候会对static变量进行初始化。如果你的代码尝试不用实例来访问非static的变量,编译器会报错,因为这些变量还没有被创建出来,还没有和任何实例关联上。

2.1.5 使用final关键字修饰一个变量时,是引用不能变,还是引用的对象不能变?

使用final关键字修饰一个变量时,是指引用变量不能变,引用变量所指向的对象中的内容还是可以改变的。

2.1.6 请说出作用域public,private,protected,以及不写时的区别?

这四个作用域的可见范围如下表所示。

说明:如果在修饰的元素上面没有写任何访问修饰符,则表示空的(default)。

2.2 代码题:

2.2.1 请使用面向对象思想描述Person类(姓名,年龄,住址)

要求包含成员变量和成员方法,构造方法(无参,满参)

主方法中匿名调用该成员方法并打印

答案:

public class Person {private String name;private int age;private String addr;Person(){} Person(String name,int age,String addr){this.name = name;this.age = age;this.addr = addr;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getAddr() {return addr;}public void setAddr(String addr) {this.addr = addr;}//成员show方法public void show(){System.out.println("该学生信息:\n"+"姓名:"+name+"\n年龄:"+age+"\n住址:"+addr);}}public class Test_3 {public static void main(String[] args) {new Person("张三",12,"昌平修正大厦六楼").show();}}

2.2.2 请使用面向对象思想描述工人类(姓名,年龄,工资,月份)

要求包含成员变量和成员方法,构造方法(无参,满参)

主方法中要求调用method(工人1,工人2)方法使用匿名对象传参;

method方法内要求计算两位工人当前月份的工资和,并返参打印

答案:

public class Worker{private String name;private int age;private double wage;private String month;public Worker(String name, int age, double wage, String month) {super();this.name = name;this.age = age;this.wage = wage;this.month = month;}public Worker() {super();}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public double getWage() {return wage;}public void setWage(double wage) {this.wage = wage;}public String getMonth() {return month;}public void setMonth(String month) {this.month = month;} } public static void main(String[] args) {double method = method(new Worker("zhangsan",12,1000,"12"),new Worker("zhangsan",12,1000,"12"));System.out.println(method);}public static double method(Worker w1,Worker w2){ return w1.getWage()+w2.getWage();}

2.2.3 编写一个计算器工具类,提供如下几个功能,如:编写两个数的加法、减法、乘法、除法的功能,然后进行测试

答案:

public class Calculator {public static double addition(double d1, double d2){//加法return d1 + d2;}public static double subtraction(double d1, double d2){//减法return d1 - d2;}public static double multiply(double d1, double d2){//乘法return d1 * d2;} public static double division(double d1, double d2) {//除法if (d2 == 0) {System.out.println("对不起,除数不能为0");return -0;}return d1 / d2;}}

2.2.4 编写一个手机类,提供两个属性,一个品牌,一个颜色,再提供一个打电话的功能,和一个展示手机的功能 然后进行测试

比如: 手机

属性: 品牌,颜色 --定义成私有的

方法: 电话 功能 ---定义成静态的

展示 展示手机的品牌和颜色

答案:

class Phone{private String brand;private String color;public Phone(){}public Phone(String brand,String color){this.brand = brand;this.color = color;}public static void call(){System.out.println("打电话");}public void show(){System.out.println("手机的品牌是:"+brand+",的颜色是:"+color);}}public class Test { public static void main(String[] args) { Phone.call();//静态方法可以直接通过类名调用 Phone p = new Phone("苹果","土豪粉"); p.show();//非静态方法只能对象调用 }}

2.2.5 编写java程序,创建一个类Hello;

在类中定义一个String类型的成员变量和一个String类型的静态变量;

然后在定义两个无返回值的方法,一个定义为成员方法,另一个定义为静态方法;

最后测试它们是否能使用成员变量和静态变量。

答案:

public class Hello {public String s1 = "aaa";public static String s2 = "bbb";public void method(){System.out.println(s1);System.out.println(s2);}public static void function(){System.out.println(s1);System.out.println(s2);}public static void main(String[] args) {new Hello().method();function();}}测试结果:在静态方法function() 中,无法访问非静态成员 s1。

原文发布于微信公众号 - Java帮帮(javahelp)

原文发表时间:2018-05-27

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Flutter入门

About Kotlin-Kotlin中的类1About Kotlin(1)

因为是从Java的角度来学习Kotlin,在Java中,类作为第一等公民。故学习Kotlin,也先从其的类开始。

863
来自专栏Kevin-ZhangCG

[ Java学习基础 ] Java异常处理

2196
来自专栏Android干货

浅谈Kotlin(三):类

1234
来自专栏Kiba518

C#语法——泛型的多种应用

泛型是.NET Framework 2.0 版类库就已经提供的语法,主要用于提高代码的可重用性、类型安全性和效率。

813
来自专栏java一日一条

Java字符串之性能优化

在程序中你可能时常会需要将别的类型转化成String,有时候可能是一些基础类型的值。在拼接字符串的时候,如果你有两个或者多个基础类型的值需要放到前面,你需要显式...

552
来自专栏个人随笔

Java 高级开发必修知识---反射

程序猿们经常说的一句话:反射反射。。。程序员的快乐 反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法; 对于任意一个对象,都能够调用它的...

3705
来自专栏程序员互动联盟

【编程基础】如何理解java中的多态

大家都知道Java面向对象有几大特征:抽象、封装、继承和多态,Java的这些特性让Java变得很强大,可以很轻松的胜任比较复杂的项目开发。今天重点给大家说说多态...

33610
来自专栏java一日一条

基础类型转化成String

在程序中你可能时常会需要将别的类型转化成String,有时候可能是一些基础类型的值。在拼接字符串的时候,如果你有两个或者多个基础类型的值需要放到前面,你需要显式...

602
来自专栏老马说编程

(91) Lambda表达式 / 计算机程序的思维逻辑

在之前的章节中,我们的讨论基本都是基于Java 7的,从本节开始,我们探讨Java 8的一些特性,主要内容包括: 传递行为代码 - Lambda表达式 函数式...

1828
来自专栏日常分享

栈的Java简单实现

  进行插入和删除操作的一端称为“栈顶”(top),另一端称为“栈底”(bottom)。

541

扫码关注云+社区