第十三天 面向对象-final&static&匿名对象&内部类&包&代码块【悟空教程】
第13天 面向对象
第1章面向对象其他知识点
1.1final与static关键字
1.1.1final关键字
1.1.1.1final概念
继承的出现提高了代码的复用性，并方便开发。但随之也有问题，有些类在描述完之后，不想被继承，或者有些类中的部分方法功能是固定的，不想让子类重写。可是当子类继承了这些特殊类之后，就可以对其中的方法进行重写，那怎么解决呢？
要解决上述的这些问题，需要使用到一个关键字final，final的意思为最终，不可变。final是个修饰符，它可以用来修饰类，类的成员，以及局部变量。
1.1.1.2final的特点
final修饰类不可以被继承，但是可以继承其他类。
classYy {}
finalclassFu extendsYy{} //可以继承Yy类
classZi extendsFu{} //不能继承Fu类
final修饰的方法不可以被覆盖,但父类中没有被final修饰方法，子类覆盖后可以加final。
classFu {
// final修饰的方法，不可以被覆盖，但可以继承使用
publicfinalvoidmethod1(){}
publicvoidmethod2(){}
}
classZi extendsFu {
//重写method2方法
publicfinalvoidmethod2(){}
}
final修饰的变量称为常量，这些变量只能赋值一次。
finalinti= 20;
i= 30; //赋值报错，final修饰的变量只能赋值一次
引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改。
finalPerson p= newPerson();
Person p2= newPerson();
p= p2; //final修饰的变量p，所记录的地址值不能改变
p.name= "小明";//可以更改p对象中name属性值
p不能为别的对象，而p对象中的name或age属性值可更改。
修饰成员变量，需要在创建对象前赋值，否则报错。(当没有显式赋值时，多个构造方法的均需要为其赋值。)
classDemo {
//直接赋值
finalintm= 100;
//final修饰的成员变量，需要在创建对象前赋值，否则报错。
finalintn;
publicDemo(){
//可以在创建对象时所调用的构造方法中，为变量n赋值
n= ;
}
}
1.1.1.3final注意事项
引用类型的变量值为对象地址值，地址值不能更改，但是地址内内容可以修改。
如：
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.2static关键字
1.1.2.1static概念与功能;
当在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。可是不创建对象，方法又调用不了，这时就会想，那么我们能不能不创建对象，就可以调用方法呢？
可以的，我们可以通过static关键字来实现。static是静态修饰符，一般修饰成员。被static修饰的成员属于类，不属于单个这个类的某个对象。
被static修饰的成员可以并且建议通过类名直接访问。也可以通过某个对象访问到属于类的静态成员，多个对象共享使用同一个静态成员。
1.1.2.2static特点：
static是静态修饰符，一般修饰成员。被static修饰的成员属于类，不属于单个这个类的某个对象。
static修饰的成员被多个对象共享。
static修饰的成员属于类，但是会影响每一个对象。
被static修饰的成员又叫类成员，不叫对象的成员。
如下例中国籍变量，所有中国人国籍均应该为中国，不应各自定义各自的国籍，所以可以将国籍定义为static，属于类，被多个对象共享。
1.1.2.3static注意事项
静态内容是优先于对象存在，只能访问静态，不能使用this/super。静态修饰的内容存于静态区。
同一个类中，静态成员只能访问静态成员
main方法为静态方法仅仅为程序入口，不属于任何一个对象，所以可以定义在任意类中。
1.1.2.4static修饰后成员的使用
被static修饰的成员可以并且建议通过类名直接访问。也可以通过某个对象访到属于类的静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员。
格式：
类名.静态成员变量名
类名.静态成员方法名(参数)
对象名.静态成员变量名 ------不建议，出现警告
对象名.静态成员方法名(参数) ------不建议，出现警告
代码演示：
classDemo {
//静态成员变量
publicstaticintnum= 100;
//静态方法
publicstaticvoidmethod(){
System.out.println("静态方法");
}
}
classTest {
publicstaticvoidmain(String[] args) {
System.out.println(Demo.num);
Demo.method();
}
}
1.1.3static与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方法，重新创建了一个匿名对象
匿名对象可以作为方法接收的参数、方法返回值使用（使用可以在任意位置）
classDemo {
publicstaticPerson getPerson(){
//普通方式
//Person p = new Person();
//return p;
//匿名对象作为方法返回值
returnnewPerson();
}
publicstaticvoidmethod(Person p){}
}
classTest {
publicstaticvoidmain(String[] args) {
//调用getPerson方法，得到一个Person对象
Person person= Demo.getPerson();
//调用method方法
Demo.method(person);
//匿名对象作为方法接收的参数
Demo.method(newPerson());
}
}
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
注意：声明包的语句，必须写在程序有效代码的第一行（注释不算）
代码演示：
.javahelp; //包的声明，必须在有效代码的第一行
import java.util.Scanner;
import java.util.Random;
public class Demo {}
1.4.3包的访问
在访问类时，为了能够找到该类，必须使用含有包名的类全名（包名.类名）。
包名.包名….类名
如： java.util.Scanner
java.util.Random
.javahelp.Demo
带有包的类，创建对象格式：包名.类名 变量名 = new包名.类名();
.javahelp.Demo d = new .javahelp.Demo();
前提：包的访问与访问权限密切相关，这里以一般情况来说，即类用public修饰的情况。
类的简化访问
当我们要使用一个类时，这个类与当前程序在同一个包中（即同一个文件夹中），或者这个类是java.lang包中的类时通常可以省略掉包名，直接使用该类。
如：cn.itcast包中有两个类，PersonTest类，与Person类。我们在PersonTest类中，访问Person类时，由于是同一个包下，访问时可以省略包名，即直接通过类名访问 Person。
类名 变量名 = new类名();
Person p = new Person();
当我们要使用的类，与当前程序不在同一个包中（即不同文件夹中），要访问的类必须用public修饰才可访问。
package .javahelp02;
public class Person {}
/*
* 用public修饰的类 可以在其他包中访问 使用默认权限修饰的类 只能在本包下访问 其他包无法访问
*/
public class Tree {
public void chengLiang(){
System.out.println("可以乘凉");
}
}
import .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.4import导包
我们每次使用类时，都需要写很长的包名。很麻烦，我们可以通过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 .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("静态代码块执行了");
}
}
publicclassPerson {
privateString name;
//成员代码块 又叫构造代码块 对象级别的代码块，每次创建对象都会执行一次
{
System.out.println("我是构造代码块");
}
//静态代码块 类级别的代码块，只有第一次创建对象时才运行，之后创建对象就不执行了
static{
System.out.println("静态代码块");
}
publicPerson(String name) {
super();
this.name= name;
}
publicPerson() {
super();
}
publicString getName() {
returnname;
}
publicvoidsetName(String name) {
this.name= name;
}
}
publicclassTest {
publicstaticvoidmain(String[] args) {
inta= 10;
//局部代码块限定变量作用域范围
{
System.out.println(a);
intb= 20;
System.out.println(b);
}
// System.out.println(b);
Person p= newPerson();
Person p2= newPerson("刘备");
Person p3= newPerson("刘备");
Person p4= newPerson("刘备");
Person p5= newPerson("刘备");
}
}
第2章本日学习作业
2.1知识点相关题：
2.1.1定义Person对象，包含Stringname,int age ,String addr成员属性和满参构造方法，创建show方法展示该对象的名字，年龄和家庭住址
1）使用匿名方法创建对象传参并调用show方法，并在控制台打印
2.1.2匿名内部类 补全代码
interfaceInter{
voidshow();
}
classOuter{
//补全代码
}
classOuterDemo{
publicstaticvoidmain(String[] args) {
Outer.method().show();//HelloWorld
}
答案：publicstaticInter method(){
returnnewInter(){
@Override
publicvoidshow() {
System.out.println("HelloWorld");
}
};
}
2.1.3static方法与普通方法有什么区别？
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类（姓名，年龄，住址）
要求包含成员变量和成员方法，构造方法（无参，满参）
主方法中匿名调用该成员方法并打印
答案：
publicclassPerson {
privateString name;
privateintage;
privateString addr;
Person(){
}
Person(String name,intage,String addr){
this.name= name;
this.age= age;
this.addr= addr;
}
publicString getName() {
returnname;
}
publicvoidsetName(String name) {
this.name= name;
}
publicintgetAge() {
returnage;
}
publicvoidsetAge(intage) {
this.age= age;
}
publicString getAddr() {
returnaddr;
}
publicvoidsetAddr(String addr) {
this.addr= addr;
}
//成员show方法
publicvoidshow(){
System.out.println("该学生信息：\n"+"姓名："+name+"\n年龄："+age+"\n住址："+addr);
}
}
publicclassTest_3 {
publicstaticvoidmain(String[] args) {
newPerson("张三",12,"昌平修正大厦六楼").show();
}
}
2.2.2请使用面向对象思想描述工人类（姓名，年龄，工资，月份）
要求包含成员变量和成员方法，构造方法（无参，满参）
主方法中要求调用method(工人1，工人2)方法使用匿名对象传参；
method方法内要求计算两位工人当前月份的工资和，并返参打印
答案：
publicclassWorker{
privateString name;
privateintage;
privatedoublewage;
privateString month;
publicWorker(String name, intage, doublewage, String month) {
super();
this.name= name;
this.age= age;
this.wage= wage;
this.month= month;
}
publicWorker() {
super();
}
publicString getName() {
returnname;
}
publicvoidsetName(String name) {
this.name= name;
}
publicintgetAge() {
returnage;
}
publicvoidsetAge(intage) {
this.age= age;
}
publicdoublegetWage() {
returnwage;
}
publicvoidsetWage(doublewage) {
this.wage= wage;
}
publicString getMonth() {
returnmonth;
}
publicvoidsetMonth(String month) {
this.month= month;
}
}
publicstaticvoidmain(String[] args) {
doublemethod = method(newWorker("zhangsan",12,1000,"12"),newWorker("zhangsan",12,1000,"12"));
System.out.println(method);
}
publicstaticdoublemethod(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。
第十三天 面向对象-final&static&匿名对象&内部类&包&代码块【悟空教程】
