Java基础_3 类与对象、接口、匿名内部类

最新推荐文章于 2022-04-10 09:07:54 发布

可以睡觉但是没必要

最新推荐文章于 2022-04-10 09:07:54 发布

阅读量136

点赞数

分类专栏： java基础文章标签： java基础类于对象接口匿名内部类

本文链接：https://blog.csdn.net/SleepNot_Need/article/details/100069710

版权

java基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

类与对象

类与对象的关系
1. 对象是类的一个实例，类是对象的一个模板
类的组成
1. 变量：对象的状态
2. 方法：对象的功能单元
3. 变量分类
  1. 全局变量：定义在方法外，类内
  2. 实例变量：类内
  3. 静态变量：被static修饰、通过（类名.变量名）来访问
  4. 局部变量：定义在方法内
4. 方法分类
  1. 实例方法:类里面的函数
  2. 静态方法：static标签的函数
  3. 构造方法：
    1. 方法名与类名一样
    2. 无返回值
    3. 实例化对象是被执行
    4. 不手写系统自建（无参构造）
    5. 可有参数
代码加载过程
1. 源代码放在.java文件中
2. java文件->编译器编译->生成.class文件（字节码文件）
3. 类加载->外部.class文件加载到JVM的过程
4. 类加载器->双亲委派机制（算法）
5. JVM中内存分区
  1. 栈：局部变量、对象的应用
  2. 堆：通过new得到的对象
  3. 方法区：静态变量、常量、方法的信息

类的继承

包：一个类库单元
访问控制
- private：本类中可访问
- defalut：同包不同类可访问
- protected：同包不同类可访问
- public：所有类可访问

继承（extends）

class person{}
class Student extends Person{}

重写、重载
- 变量隐藏：子类出现与父类相同的变量名时，会把父类的变量隐藏，可通过super关键字进行引用
- 方法重写（override）：子方法的权限修饰符不能比父方法更严格
- 方法的重载（overload）：参数个数、类型、顺序不同

super关键字

super.变量名/方法名：调用父类的方法或者成员变量

class Person{
    String name;	//示例变量
    public void Say(){	//示例方法
        system.out.println("hello");
    }
}
class Student extends Person{
    int name;
    system.out.println(super.name);
    public void Say(){	//重写Say方法
        super.Say();	//调用父类Say方法
        system.out.println("hello world") 
    }
}

super(参数) ：显示的调用父类的构造方法(父类有多个方法时)

class Person{	//父类
    String name_F;
    public Person(String name){	//父类构造方法
        this.name_F=name;
    }
}
class Student extends Person{	//子类
    int age_;
    public Student(String name,int age){	//子类构造方法
        super(name);	//调用父类构造方法
        this.age_=age;
    }
}

抽象类（abstract）

抽象类

public abstract class xx{} 	//抽象类需要用abstract修饰

抽象方法
```
public abstract viod xx();	//抽象方法需要用abstract修饰
```
- 产生：当子类的共性不断向上抽取，抽到一定程度，有些方法不知道如何实现。
- 作用：强制子类重写

接口（interface）

接口的概念
- 接口是功能的集合
- 接口中只定义方法，不定义普通成员变量
- 接口中的成员方法必须都是抽象的
- 接口不等得创建对象

接口的定义

public interface 接口名字{
    //最好不定义普通成员变量
    public abstract void 方法名();	//方法必须为抽象方法
}

接口的继承（可多继承）

public interface MyInterMain extends MyInter01,MyInter02 {
    //实现接口中的所有抽象方法
}

类和接口

实现（implements）：类实现接口，一个类可实现多个接口

public class demo01 implements MyInter01,MyInter02{
	....//重写接口里的所有抽象方法
}

接口中成员的特点
- 成员变量：需用固定修饰符public static final可不写
```
public static final int a = 10;
```
  可以不写，编译器自动生成修饰符
- 成员方法：需要用固定修饰符public abstract可不写
```
public abstract void 接口名字();
```
- 接口不可创建对象
- 实现类实现接口时，必须重写所有的抽象方法才能创建对象，否则实现类依然是抽象类
- 开发中最常用的模式
```
public class A extends AbstractClassB implements 接口A,接口B		//一个类继承一个抽象类，实现多个接口
```
A中必须重写抽象类中的抽象方法，以及所有接口的抽象方法
接口与抽象类的区别
- 相同点
  1. 都不能创建对象
  2. 都是作为父类/父接口
  3. 子类/实现类都必须重写抽象方法，才能创建对象
- 不同点
  1. 关键字不同
  2. 抽象类可以有抽象方法、可以没有、也可以都要
  3. 接口只能有方法切必须都是抽象的
  4. 抽象类可以定义人数成员变量，接口只能定义用public static final 修饰的成员变量
  5. 类与抽象类之间的关系是单继承，类与接口之间是多实现
  6. 思想上的区别：
    - 抽象类中必须定义整个继承体系的共性内容
    - 接口定义整个继承体系职位额外的扩展功能

抽象类与接口作为方法参数或返回值

抽象类

public Animal getAnimal() {
	return new Animal() {	//创建一个匿名Animal抽象类的子类作为返回值

		@Override
		public void eat() {
			// TODO Auto-generated method stub
			......
		}
	};
}

接口(同理)

public myInteeface getAnimal() {
	return new myInterface() {	//创建一个匿名myInterface接口的实现类作为返回值

		@Override
		public void eat() {
			// TODO Auto-generated method stub
			......
		}
	};
}

类的多态

多态的定义
- 一个对象的多种形态
  
  如：你在学校是学生，在家是儿子，在公司是员工。
- java中的多态：
  - 前提：
    1. 必须有自父类关系（必须有继承）
    2. 必须有方法的重写
  - 体现形式：
    
    父类类型变量名 = new 子类类型
```
Fu fu = new Zi();
```
多态的注意事项

使用多态调用成员变量和成员方法时：
- 多态使用变量—编译运行都调父类
- 多态调用方法—编译看父类—运行调子类

多态弊端

弊端：只能调用子父类共有的方法，不能调用子类特有的方法

好处：提高程序的灵活性

例如：喂猫，喂狗，喂猪…

//动物抽象类
public abstract class Animal{
	public abstract void eat();
}

//猫类---继承动物类，并实现eat方法
public class Cat extends Animal{
    public void eat(){
        system.out.println("喵喵吃饭饭。。。")	//实现Animal中的抽象方法
    }
    public void catchMouse(){	//猫类特有的方法
        system.out.println("抓老鼠。。。")
    }
}

//狗类---继承动物类，并实现eat方法
public class Dog extends Animal{
    public void eat(){
        system.out.println("汪汪汪吃饭饭。。。")
    }
}

//喂动物方法---通过多态实现喂各种动物
public void feedAnimal(Animal am){	//通过父类指向子类对象
    am.eat();
}

//多态实现喂各种动物
Animal A1 = new Cat();	//利用多态创建一个猫对象
Animal A1 = new Dog();	//利用多态创建一个狗对象
feelAnimal(A1);	//调用子类及猫的eat方法
feelAnimal(A2);	//调用子类及狗的eat方法

弊端解决

向上转型与向下转型

向下转型

如：实例调用猫抓老鼠的方法

Animal A3 = new Cat();
Cat cat = (Cat)A3;	//通过向下转换，解决不能调用子类特有的方法
cat.catchMouse();

弊端：编译时，不会检查是否能转换

关键字instanceof

格式：

boolean OK = A3 instanceof Cat;	//判断它是否是猫类
if(OK){	//是猫类则转换
    Cat cat1 = (Cat)cat;
}

static关键字

通过类名. 访问（可用对象访问）
静态代码块：当创建（使用）这个类是，JVM自动执行静态代码块
- 作用：用来初始化类（mysql数据用静态代码块来加载驱动）
- 示例
```
public class demo01 {	//类
	static {	//当使用这个类时执行，且只执行一次
		System.out.println("顶顶顶。。。");
	}
}
```

final关键字

final可修饰：类、成员变量、成员方法、局部变量
- 修饰类：此类不能被继承
- 成员变量：
  - 创建时，必须赋值
  - 并不能修改值
- 成员方法：不能被子类重写
- 局部变量：
  - 基本类型：只能被赋值一次
  - 引用类型：其指向的地址不能改变，但是对象中的内容可变

包

包的声明
- 格式：package 包名
- 作用：指示某个类在哪个包下
包的导入
- 格式：import 包名.类名
- 作用：告诉编译器，要使用的类在哪个包下

权限修饰符

	public	protected	default	private
本类	OK	OK	OK	OK
同包不同类	OK	OK	OK
不同包不同类	OK

匿名内部类

作用：

快速创建抽象类的子类对象

Animal a1 = new Animal() {	
    //Animal是一个抽象类
    //此方法快速创建一个Animal抽象类的子类对象
    //再通过多态用a1指向这个子类对象
    
	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("吃吃吃。。。");
	}

	@Override
	public void sleep() {
		// TODO Auto-generated method stub
			System.out.println("睡睡睡。。。");
	}
			
};	//访问Animal子类中的eat()方法

快速创建接口（同理）

myInterface my = new myInterface(){	
    //myInterface是一个接口
    //此方法创建一个myInterface接口的一个实现类
    //并用多态用my指向这个实现类
    
    @Override
    ...//实现所有抽象方法
};

可以睡觉但是没必要

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础_3 类与对象、接口、匿名内部类

类与对象类与对象的关系对象是类的一个实例，类是对象的一个模板类的组成变量：对象的状态方法：对象的功能单元变量分类全局变量：定义在方法外，类内实例变量：类内静态变量：被static修饰、通过（类名.变量名）来访问局部变量：定义在方法内方法分类实例方法:类里面的函数静态方法：static标签的函数构造方法：方法名与类名一样无返回值实例化对象是被...
复制链接

扫一扫