- 1. 包
- 1.1 包的概述
- 1.2 导包
- 2.修饰符
- 2.1 权限修饰符
- 2.2 状态修饰符
- final
- static关键字
- 3. 多态
- 3.1 多态概述
- 3.2 多态中成员访问特点
- 3.3 多态的好处与弊端
- 3.4 多态中的转型
- 4.抽象类
- 4.1 抽象类概述
- 4.2 抽象类特点
- 4.3 抽象类的成员特点
包的概述和使用】:
包其实就是文件夹，它的作用就是进行分类管理的
格式:package 包名;(多级包用.分开)
范例:package com.demo;
方法:
1.带包的Java类编译和执行手动建包:按照以前的格式编java文件
javac HelloWorld.java
2.手动创建包
在E盘建立文件夹com,然后在com下建立文件夹demo
把class文件放到包的最里面，把HelloWorld.class文件放到com 下的demo这个文件夹下，带包执行
java com.demo.HelloWorld1.2 导包
对于不在同一个目录下的java类，如果想要实现类与类之间的测试与调用，那么就需要进行导包
- 格式：import 包名；
- 范例：import.com.test;
- private同一个包可在本类中都可以被访问到，其他的类中不可被访问
- protected同一个包下可进行访问，不在同一个包下子类也进行访问，但无关类不可进行访问无关类：未继承父类的类
- public 都可以进行访问
- 默认 不同包的子类，和无关类不可进行访问
- final 关键字是最终的意思，可以修饰成员方法，成员变量，类
举例:
1.定义一个父类：
public class Fu {
public void show(){
System.out.println("父中方法被调用");
}
}
定义子类：
public class Zi extends Fu {
@Override//用来检测重写方法时方法名单词是否拼写错误
public void show(){
System.out.println("子中方法被调用");
}
}
定义测试类：
public class jicheng {
public static void main(String[] args) {
Zi z=new Zi();
z.show();
}
那么这里输出的结果就是
子类方法被调用
但是，如果在父类前加入final来修饰，那么子类中将会报错，因为最终方法不可被重写如下面所示，在方法名前加final那么就代表是最终态，不会在被重写
public class Fu {
public final void show(){
System.out.println("父中方法被调用");
}
}
同样的对于成员变量如果在前面加入final这个修饰符，就代表最终态，就是一个常量了，不可在局部变量中在进行赋值
public class demo{
public final int age=10;
public void zi(){
age=20;//这里赋值也不会再起作用，还会报错
}
}
还有final修饰类，就代表是最终类，就不能被使用:
public final class Fu {
public void show(){
System.out.println("父中方法被调用");
}
}
上面有final修饰类，那么子类就不能继承
总结:
final修饰的特点
- 修饰方法：修饰方法:表明该方法是最终方法，不能被重写
- 修饰变量：表明该变量是常量，不能再次被赋值
- 修饰类：表明该类是最终类，不能被继承
final 修饰局部变量：
- 修饰基本类型变量
被它修饰后，局部变量不可再用 - 修饰引用类型
对于修饰类型，修饰的是地址，而里面的内容可以改变
public class Student{
public int age=10;
}
那么它输出的就会是100，而不是10
总结：
- 变量是基本类型: final修饰指的是基本类型的数据值不能发生改变
- 变量是引用类型: final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的
static 是静态的意思，可以修饰成员方法，成员变量
对于一个事物，别的事物都需要它来共享，这样建议使用static来进行修饰
例如，很多个学生来自同一个大学，但年龄，性别不同，这里，赋值时，因为多个同学来自同一个大学，那么大学就是一个静态的，共享的，赋值时如果给每个学生大学都赋值同一个大学，那么会显得臃肿，用static修饰大学就是不错的选择
主函数部分：
public class main {
public static void main(String[] args) {
stu.university="清华大学";//直接给大学赋值，建议使用这种方式来进行给静态赋值
stu s1=new stu();
s1.name="张三";
s1.age=18;
s1.show();
stu s2=new stu();
s2.name="李四";
s2.age=19;
s2.show();
}
学生类部分
public class stu{
public String name;
public int age;
public static String university;//加上静态修饰符，可以共享
public void show(){
System.out.println(name+", "+age+", "+university);
}
}
那么输出结果就是：
张三, 18, 清华大学 李四, 19, 清华大学
访问特点:
**概述：**同一对象，在不同时刻表现出来的不同形态
- 有继承关系：
public class Cat extends Animal{//继承关系
@Override
public void eat(){//方法重写
System.out.println("猫爱吃鱼");
}
}
- 方法重写：
public class Animal {
public void eat(){
System.out.println("动物吃肉");
}
}
- 父类引用指向子类对象：
public class AnimalDemo {
public static void main(String[] args) {
Animal animal=new Cat();//多态，父类引用指向子类对象，这里也就是下面说的向上转型
}
}
3.2 多态中成员访问特点
成员变量：编译看左边，执行看左边
成员方法：编译看左边，执行看右边
//子类
public class Cat extends Animal{//继承关系
public int age=40;
@Override
public void eat(){//方法重写
System.out.println("猫爱吃鱼");
}
public void playGame(){
System.out.println("猫爱玩");//非重写
}
}
//父类
public class Animal {
public int age=30;
public void eat(){
System.out.println("动物吃肉");
}
}
//测试类
public class AnimalDemo {
public static void main(String[] args) {
Animal animal=new Cat();//多态
System.out.println(animal.age);
//运行结果是左边Animal,则age=30,
//如果Animal没有age，则会报错
//----------------------------------
animal.eat();//方法重写执行看右面
//输出的是Cat里面的方法
//----------------------------------
animal.playGame();//这时就会报错
//执行左面Animal里面没有这个方法
}
}
为什么成员变量和成员方法的访问不一样呢?
因为成员方法有重写,而成员变量没有
测试类
狗类：
猫类：
操作类：
测试结果：
- 向上转型 从子到父，父类引用指向子类对象
- 向下转型 从父到子，父类引用转为子类对象
向上转型，上面的有实例，这里不在叙述，
关于向下转型，也就是在子类中，如果不用父类的方法时，想要用自己的方法时，还不能出现报错，这里就要用向下转型，从而实现
例如：
在猫类中有方法eat，而猫类继承父类，父类也有eat方法，这就实现了猫类方法重写，而在猫类中还有方法Game(),而父类没有此方法，那么使用时就会报错，如果不想报错，就要实施类似强转
//子类
public class Cat extends Animal{//继承关系
@Override
public void eat(){//方法重写
System.out.println("猫爱吃鱼");
}
public void playGame(){//这里方法没被重写，按照编译看左面，看父类中没有就会报错，
//下面向下转型就可以实现这个问题
System.out.println("猫爱玩");//非重写
}
}
//父类
public class Animal {
public void eat(){
System.out.println("动物吃肉");
}
}
//测试类
public class AnimalDemo {
public static void main(String[] args) {
Animal animal=new Cat();//多态，向上转型，父类引用指向子类对象
animal.eat();//这里因为有重写方法，所以执行看右面，看cat中的eat,所以会输出猫爱吃鱼
Cat c= (Cat)animal;//后面的(Cat)animal是父类引用作为子类对象，转为Cat,
//那么就可以实现调用子类独有的方法了
c.playGame();
}
}
4.抽象类
4.1 抽象类概述
概述
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类
用abstract表示抽象
public abstract class Animal {//抽象类
public abstract void eat();//定义抽象方法
}
4.2 抽象类特点
实例化
//猫类
public class Cat extends Animal{//继承关系
public void eat() {//重写父类方法，有抽象类的方法
System.out.println("猫吃鱼");
}
}
//Animal类
public abstract class Animal {//抽象类
public abstract void eat();//定义抽象方法
public void sleep(){//抽象类中一定有抽象的方法，但也可有不抽象的方法
System.out.println("睡觉");
}
}
//狗类
public abstract class dog extends Animal {
//这里如果不想重写所有方法，就需要在加abstract
}
测试类
public class AnimalDemo {
public static void main(String[] args) {
Animal c = new Cat(); //采用多态方式
c.eat();//调用eat方法，遵循编译看左面，执行看右面
c.sleep();//尽管猫类中没有，但是会继承父类中的
}
}
运行结果 猫吃鱼 睡觉4.3 抽象类的成员特点
- 可以提供构造方法，但是不能实例化
- 构造方法作用是子类访问父类数据的初始化
- 成员变量可以是变量，也可以是常量
- 成员方法 可以有抽象方法：限定子类完成某些动作；也有非抽象方法：提高代码复用性
public abstract class xxx(){
public xxx(){}//无参构造方法
public xxx(String name){//有参构造方法
this.name=name;
}
}
public abstract class xxx(){
private final int age=10;//可以是常量
private String name;//也可以是变量
}
public abstract class xxx(){
public void sleep(){//非抽象方法，提高复用性
System.out.println("睡觉");
}
}
public abstract class xxx(){
public abstract void eat();
//限定猫类中重写eat方法，否则报错
}
