封装
使用private关键字去修饰变量和方法,使变量和方法只能够在本类当中使用,但他会给本类提供接口,让其他类来间接访问本类当中的数据。
public class Animal{
private String name;
private int age;
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
if (age<0){
System.out.println("error");
}else{
this.age=age;
}
}
public int getAge(){
return age;
}
public void introduce(){
System.out.println("我叫"+name+"今年"+age);
}
public static void main(String[] args){
Animal dog=new Animal();
dog.setAge(-18);
dog.setName("daHuang");
dog.introduce();
}
}
继承
注意:
子类拥有父类除 private 以外的所有属性和方法(就是代码)。
子类可以拥有自己的属性和方法。
子类可以重写实现父类的方法。
Java 中的继承是单继承,一个类只有一个父类。
语法格式
class 子类 extends 父类{}
public class Animal {
public int legNum; //动物四肢的数量
//类方法
public void bark() {
System.out.println("动物叫!");
}
}
//Dog类继承Animal类
public class Dog extends Animal {
}
public class Test{
public static void main(String[] args) {
Dog a = new Dog();
a.legNum = 4;
a.bark();
}
}
多态
抽象类
抽象类定义:
1.抽象类和抽象方法必须都有abstract
2.抽象类不能被实例化,也就是不能new关键字去产生对象。
3.抽象类的子类必须复写所有的抽象方法后才能被实例化,否则这个子类还是个抽象类。
注意:
抽象类当中可以有普通方法和抽象方法。
抽象方法
抽象方法就是在方法的前面加上 abstract,他也有普通方法的功能和属性。
其父类必须是抽象类(再类名前面加上abstract),继承的子类必须重写父类中的抽象方法。
接口
接口用于描述类所具有的功能(就是更加抽象的类),而不提供功能的实现。
接口语法:
修饰符 interface A extends 接口1,接口2{
public static final 数据类型 成员名称 = 常量; //数据成员必须赋初值,其中public static final 可以不写
abstract 返回值的数据类型 方法名称(参数..); //抽象方法,注意在抽象方法里,没有定义方法主体
default 返回值的数据类型 方法名称(参数..){}
static 返回值的数据类型 方法名称(参数...){}
}
以上方法都有public都可以默认不行,会自动添加。
访问接口:
全局常量:实现类.常量
静态方法:接口名.方法名
抽象方法和默认方法 : 通过接口 的实现类 的对象来访问
注意:
implements实现接口,并实现接口中的全部抽象函数。其中实现的类必须把接口中的方法全都去重写。
接口的实现:
class 类名称 [extends 父类名] implements 接口A,接口B
{
...
}
接口不能用于实例化对象。
public class Animal {
public static void main(String[] args) {
System.out.println(dogName.ID);//全局常量获取:实现类.
dogName daHuang=new dogName();
daHuang.breathe(); //抽象函数获取:实现类对象.
daHuang.getType("金毛"); //默认函数获取:实现类对象.
System.out.println(Dog.getID()); //静态函数获取:接口名.
}
}
多态
多态: 都是同一个类型,调用同一个方法,却能呈现不同的状态
Animal a = new Animal(); //a是父类的引用指向的是本类的对象
Animal b = new Dog(); //b引用的数据类型和对象的数据类型不一致
为啥会出现多态?
b调用方法的时候实际调用的是Dog()重写后的方法
多态条件
1、b是父类的引用指向的是子类的对象
2、调用的方法有重写
public class Dog {
public void blak(){
System.out.println("wangwang");
}
}
public class Animal extends Dog{
String name;
int age;
public void blak(){
System.out.println("动物叫");
}
public static void main(String[] args){
Dog daHuang=new Animal();
daHuang.blak();//动物叫
}
}
内部类
非静态类
非静态内部类可以直接在一个类里面定义
public class Animal{
private String name;
float hp;
String blak;
// 非静态内部类,只有一个外部类对象存在的时候,才有意义
class BattleScore{
int kill;
int die;
int assit;
public void legendary(){
if(kill>=8)
System.out.println(name+"咬了");
else
System.out.println(name+"被咬了");
}
}
public static void main(String [] args){
Animal dog=new Animal();
dog.name="daHuang";
// 实例化内部类
BattleScore score=dog.new BattleScore();
score.kill=9;
score.legendary();
}
}
调用方式:父类引用.子类对象
如 dog.new BattleScore();
静态内部类
静态内部类 不需要一个外部类的实例为基础,可以直接实例化
语法:new 外部类.静态内部类();
因为没有一个外部类的实例,所以在静态内部类里面不可以访问外部类的实例属性和方法
访问静态内部类的类方法和实例方法
public class Main {
static class InnerClass{
public static void m(){
System.out.println("静态内部类方法");
}
public void m_1(){
System.out.println("实例方法");
}
}
public static void main(String[] args) {
Main.InnerClass.m();
Main.InnerClass mi= new Main.InnerClass();
mi.m_1();
}
}
局部内部类
定义在方法中的类,有效范围在方法之中。
局部内部类可以访问外部类的所有成员和方法,但是内部类的成员和方法仅限于此方法中使用。
public class Animal{
int m=1;
void test1(){
System.out.println("外部成员类方法");
}
void test2() {
//定义局部内部类Inner,在局部内部类中访问外部类变量和方法
class Inner {
int n=1;
void show() {
System.out.println("外部静态变量m=" + m);
test1();
}
}
//在局部内部类的方法中,调用局部内部类变量和方法
Inner inner=new Inner();
System.out.println("局部内部类变量n="+inner.n);
inner.show();
}
public static void main (String [] args){
Animal inner=new Animal();
inner.test2();
}
}
匿名类(没有名字的类)
如果改方法的参数数一个类型,通常使用匿名类。
匿名内部类创建语法
interface dog{
void shout();
}
public class Animal{
public static void main(String [] args){
String name="xiaohua";
animalShout ( new dog(){
//实现shout()方法
public void shout(){
System.out.println(name+"汪汪");
}
});
}
public static void animalShout(dog an){
an.shout();
}
}