自学Java Part 3

一、关键字

1、static

表示静态，可以修饰[成员方法]，[成员变量]

被类的所有对象共享，可以通过类名调用和对象名调用

（1）、静态变量

static修饰的变量为静态变量，又叫做类变量。

格式：

static 数据类型 变量名；

可以通过类名方式或实例名方式访问静态变量，但不能被this和super访问。

（2）、静态方法

static修饰的方法叫静态方法，又叫做类方法。

格式：

[访问修饰符] static 返回数据类型 方法名（[参数列表]）{

方法体；

}

不能访问实例变量，只能访问静态变量或静态方法。

综上，静态成员方法只能访问静态成员。

2、final

final代表最终的意思，可以修饰成员方法，成员变量，类。

修饰类：为最终类，不能被继承，不能有子类，可以有父类

修饰方法：为最终方法，不能被子类重写

修饰变量：该变量是一个常量，只能赋值一次，只能被访问，不能改变值
3、super

通过super实现对父类成员的访问，是用来引用当前对象的父类，不能在静态上下文使用。

格式：

super（参数列表）       调用父类的构造函数

super.属性名                 调用子类继承的父类属性

super.方法                     调用子类继承的方法

this访问子类，super访问父类

二、继承

1、定义

继承使得子类具有父类的属性和方法，在子类中重新定义，追加属性和方法。

2、格式

class 子类 extends 父类 {

}

其中extends是表示继承关系的关键字

3、利弊

利：提高代码复用性、维护性

弊：类的耦合性提高，减弱了子类的独立性

4、特征

父类具有一般的特征，子类更加具体，除父类的特征，还有属于自己的

若子类无extends，默认子类为object类

子类不能继承父类中访问权限为private修饰的成员变量和方法

Java继承是单继承，接口间可以是多重继承

在子类方法中访问一个变量，采用的是就近原则

子类中所有的构造方法默认都会访问父类中无参的构造方法

5、修饰符

（1）、访问修饰符

访问权限	private	default	protected	public
当前类	√	√	√	√
同一包中子类无关类		√	√	√
不同包中子类			√	√
任何类				√

default为默认

（2）package、import

package

包就是文件夹

package 包名; 若为多级包，用“.”分开

带包编译：javac –d . 类名.java

带包运行：java 包名+类名

import

为了简化带包，因为使用不同包下的类时，使用的时候要写类的全路径

格式：import 包名；

6、继承应用

定义phone类

public class phone {
	private String brand;
	private int price;
	public phone() {}
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	public int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
	public phone(String brand, int price) {
		this.brand = brand;
		this.price = price;
	}
	
}
class Xiaomi extends phone{
	public Xiaomi() {}
	
	public Xiaomi(String brand, int price) {
		super(brand,price);
	}
	public void slogan(){
		System.out.println("生生不息");
		}
	
}
 class Huawei extends phone{
	 public Huawei() {}
	 
	public Huawei(String brand, int price) {
		super(brand,price);
	}
	public void slogan(){
		System.out.println("跃见非凡");
		}
	
}

定义phonetest类

public class phonetest {
	public static void main(String[] args){
		Huawei a=new Huawei();
        a.setBrand("华为mate40Pro");
        a.setPrice(6499);
        System.out.println(a.getBrand()+"  " + a.getPrice());
        a.slogan();
        Xiaomi b=new Xiaomi();
        b.setBrand("小米11Ultra");
        b.setPrice(5999);
        System.out.println(b.getBrand()+"  " + b.getPrice());
        b.slogan();
	}


}

结果

华为mate40Pro  6499
跃见非凡
小米11Ultra  5999
生生不息

三、多态

1、定义

同一个对象，在不同时刻表现出来的不同形态

同一个接口，使用的不同实例而执行不同操作
2、前提

有继承或实现关系，有方法的重写，有父类引用指向子类对象

3、利弊

利：可替换性，可扩充性，接口性，灵活性，简化性

弊：不能使用子类的特有成员

4、方法重写

运行时多态

定义：

子类出现了和父类中相同的方法声明

应用：

子类需要父类的功能，而功能主体子类有自己特有内容时，应用方法重写，但私有方法不能被重写

Override

检测是否是重写的方法

定义volume类

public class volume {
	public double getVolume() {
		return 0.0;
	}

}
class Cube extends volume{
	private double h;
	public Cube(double h) {
		this.h=h;
	}
	@Override
	public double getVolume() {
		return h*h*h;
	}
}
class Ball extends volume{
	private double r;
	public 	Ball(double r) {
		this.r=r;
	}
	@Override
	public double getVolume() {
		return 4/3*3.14*r*r*r;
	}
}

定义test类

public class test {
	public static void main(String[] args){
	Cube cube =new Cube(9);
	System.out.println("正方体体积为");
	System.out.println(cube.getVolume());
	Ball ball =new Ball(9);
	System.out.println("球体积为");
	System.out.println(ball.getVolume());
}

}

结果

正方体体积为
729.0
球体积为
2289.06

5、方法重载

编译时多态

定义：

在一个类中通过多种方式完成同一种行为 

应用：

一个类中多个方法具有相同的名字，但具有不同参数列表

6、instanceof

是二元操作符，用来测试它左边的对象是否是它右边类的实例

返回boolean类型

四、内部类

1、定义

内部类：在类中定义的类

外部类：在类外定义的类

2、格式

修饰符 class 外部类名称{

//外部类成员

修饰符 class 内部类名称{

//内部类成员

}

}

3、类型

静态的内部类

非静态的内部类

匿名类

4、特点

可以访问外部类的所有变量和方法，编译后生成外部类$内部类.class

5、优点

缩小字节码文件大小，方便访问外部类的私有属性

 

永远相信美好的事情即将发生！！！

永远相信美好的事情即将发生！！！

永远相信美好的事情即将发生！！！