Day6
包（package）
- 包 即为文件夹，用于分开不同的类，使我们能在不同文件夹中创建名称、类型相同的类。
- 在创建package时注意：包名必须是小写，而且是由一个或多个有意义的单词连缀而成
- 包可以更好地管理逻辑相关的类，可以控制不同包之间的访问权限
- 导入外部包的类，使用关键字
import
访问权限修饰符
Java中有四个权限修饰符
1>.public ： 公共权限 ， 修饰类、属性、方法。可以被类任意访问
2>.protect ： 受保护的权限 ，修饰属性、方法。
3>.default ： 同包权限 ，修饰 类、属性、方法。只能被同包的类访问
4>.private ： 私有权限 ，修饰属性、方法。 只能在本类中访问
public class Test01 {
void fangfa1(){
System.out.println("default");}public void fangfa2(){
System.out.println("public");}protected void fangfa3(){
System.out.println("protected");}private void fangfa4(){
System.out.println("private");}public static void main(String[] args) {
Test01 a = new Test01(); //同类 四种修饰符都可以使用a.fangfa1();a.fangfa2();a.fangfa3();a.fangfa4();}}//在同包不同类中
public class TestFengzhuang {
public static void main(String[] args) {
Test01 a= new Test01();a.fangfa1();a.fangfa2();a.fangfa3();//a.fangfa4(); 因为fangfa4是private所修饰的，所以不能被调用（调用报错）}
}面向对象语言的三大特征
封装
-
封装即为使用上述访问权限修饰符，来将类的某些信息隐藏在类内部，不允许外部程序直接访问，
而是通过该类提供的方法来实现对隐藏信息的操作和访问。封装的好处
-
隐藏了类的细节
-
方便加入控制语句
-
通过方法来控制成员变量的操作，提高了代码的安全性
-
把代码用方法进行封装，提高了代码的复用性
继承
- 继承可以降低代码编写的冗余度，提高编程的效率。通过继承，子类获得了父类的成员变量和方法。
- 在JAVA中使用extends关键字来表示继承关系
- JAVA不支持多继承，一个类只能有一个直接父类
- 继承之后子类可以调用父类的所有非私有属性和非私有方法
实例
//学生类
package Extends;public class Student {
//父类 学生大类int id;String name;//构造器public Student(){
System.out.println("学生类的无参构造器");}public void Study(){
System.out.println("正在学习");}public void lesson(){
System.out.println("正在上课");}}//小学生类package Extends;public class pupliStudent extends Student{
//小学生子类 继承 父类学生public pupliStudent (){
System.out.println("小学生类的无参构造器");}public void Play(){
System.out.println("做完作业可以耍");}public static void main(String[] args) {
pupliStudent a1 = new pupliStudent();a1.id = 1001;a1.Study();a1.lesson();}
}//大学生类
package Extends;public class universityStudent extends Student{
//子类大学生 继承 父类学生public void zixi(){
System.out.println("大学生应该学会自习");}public static void main(String[] args) {
universityStudent a2 = new universityStudent();a2.Study();a2.zixi();a2.lesson();}
}//计算机科学学生类package Extends;public class computerMajorStudent extends universityStudent{
//继承父类大学生public void lesson(){
//方法的重写 继承父类的方法可以进行重写，调用会默认调用子类重写的方法System.out.println("计科学生需要自学");}public static void main(String[] args) {
computerMajorStudent a3 = new computerMajorStudent();a3.Study();//继承父类的父类方法1a3.zixi();//继承父类方法1a3.lesson();}
}- 子类继承其父类的所有public和protected成员，但不能继承其父类的private成员。我们可以在父类中提供用来访问其私有字段的public或protected方法，（如父类中的setName 或 getName 方法）子类使用这些方法来访问相应的字段
Super关键字
- 子类重写了父类中的某一个方法，隐藏父类中的字段，假如想在子类中访问到父类中被重写的方法和隐藏父类的字段，可以在子类中通过使用关键字super来调用父类中被重写的方法和访问父类中被隐藏的字段。
class A{
public String name = "张三";public void print(){
System.out.println("我是张三");}
}class B extends A{
public String name = "荔枝";public void print(){
super.print(); // 使用super关键字 调用父类的print方法;System.out.println(super.name); // 使用super关键字 调用父类的成员属性System.out.println("我吃荔枝");}
}
public class Test {
public static void main(String[] args) {
B b = new B();b.print();}
}
运行结果为：
我是张三
张三
我吃荔枝
Super调用父类的无参构方法/有参构造方法
子类不继承其父类的构造方法。
- 当使用无参数的super()时，父类的无参数构造方法就会被调用；
- 当使用带有参数的super()方法时，父类的有参数构造方法就会被调用。
class Fu{
private int n ;Fu(){
System.out.println("这是父类的无参构造方法");}//父类的无参构造方法Fu(int n){
//父类的有参构造方法this.n = n;System.out.println("这是父类的有参构造方法");}
}class zi extends Fu{
private int n;zi(){
System.out.println("这是子类的无参构造方法");}//子类的无参构造方法zi(int n ){
//子类的有参构造方法super(300);//调用父类有参的构造方法System.out.println("这是子类的有参构造方法"+n);this.n = n;}}public class Test{
public static void main(String[] args) {
zi a = new zi();zi b = new zi(100);}
}运行结果
这是父类的无参构造方法
这是子类的无参构造方法
这是父类的有参构造方法
这是子类的有参构造方法100
对父类的构造放的调用必须放在子类构造方法的第一行；
如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器；
如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表；
子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）
多态
- 多态是指同一事物，在不同时刻表现出的不同种状态
多态存在的三个必要条件
- 要有继承（包括接口的实现）（前提条件
- 要有重写（前提条件）
- 父类引用指向子类对象
//当编译类型是父类，运行类型是子类时，被称为父类引用指向子类对象
class Animal{
}
class Cat extends Animal{
}
class dog extends Animal{
}
Animal x = new Cat();//Animal的引用指向了Cat对象
- 多态环境下对成员方法的调用：
class Animal{
void show() {
System.out.println("Anmial");}
}
class Cat extends Animal{
void show() {
System.out.println("cat");}
}Animal x = new Cat();
x.show() //调用的是子类中的方法
`编译看左边，运行看右边`//
- 多态环境下对静态成员方法的调用：
class Animal{
static void show() {
System.out.println(“Animal");}
}
class Cat extends Animal {
static void show() {
System.out.println(“Cat");}
}
Animal x = new Cat()
x.show() //调用的是动物类中的静态成员方法。//编译和运行都看左边
- 多态环境下对成员变量的调用
class Animal{
int num = 3;
}
class Cat extends Animal {
int num = 4;
} Animal x = new Cat()
x.num; //调用的是动物类中的成员变量。
//编译和运行都看左边 变量不存在被子类覆盖这一说法
- 方法参数具有多态性
class Animal{
void eat() {
}}
class Cat extends Animal{
void eat() {
}}
class Dog extends Animal{
void eat(){
}}
//方法的形式参数类型是父类类型，而传递的实际参数可以是任意
子类的对象
method(Animal animal){
animal .eat();方法参数多态性的好处：提高代码的扩展性
- 向上转型
class Animal{
void eat(){
}
}
class Cat extends Animal{
void look() {
System.out.println("看家");}
}
Animal x=new Cat(); //向上造型，Cat对象提升到Animal对象
x.eat() ;//只能使用父类中的方法
x.look() ;//报错！不能使用子类中的方法//向上转型的优点是 ： 可以提升代码的扩展性
- 向下转型
class Animal{
void eat(){
}
}
class Cat extends Animal{
void look() {
System.out.println("看家");}
}
Animal x = new Cat();
Cat a = (Cat)x; //向下转型m.eat();m.look();//子父类中的方法都可以使用//向下转型的作用是：为了使用子类的特有方法
final关键字
- 对参数做final修饰，
- 在方法参数前加final关键字，可以防止数据在方法体中被修改
package finalDemo;
// 被final修饰的类不能被继承
public class TestFinal {
final int age =18; //final修饰成员变量 并给其赋值final int id;public TestFinal(int id) {
// final 修饰 成员变量，使用构造方法给其赋值this.id = id;}final void Test(){
//被 final修饰的方法 不能被重写System.out.println("testdemo");}}package finalDemo;public class Test extends TestFinal{
public Test(int id) {
super(id);}}
接口（interface）
-
接口存在的意义：java中一个类只能有一个父类，所以用接口可以实现多继承的逻辑 。
-
接口是一种特殊的抽象类，这种抽象类中包含抽象方法。
接口的特点
-
接口中的所有成员变量都默认是由public static final修饰的。
-
接口中的所有方法都默认是由public abstract修饰的。
-
接口没有构造方法。构造方法用于创建对象
-
实现接口的类中必须提供接口中所有方法的具体实现内容。
-
多个无关的类可以实现同一个接口
-
一个类可以实现多个无关的接口
-
与继承关系类似，接口与实现类之间存在多态性
-
接口也可以继承另一个接口，使用extends关键字。
-
实现接口的类中必须提供接口中所有方法的具体实现内容。
-
多个无关的类可以实现同一个接口
-
一个类可以实现多个无关的接口
-
与继承关系类似，接口与实现类之间存在多态性
接口和抽象类的区别
1、抽象类可以存在已经实现了的方法，而接口不能存在实现了的方法。
2、抽象类的子类需要使用extends关键字进行继承，而接口的子类需要使用implements来继承
3、抽象类可以使用public,protect，default等修饰符进行修饰，而接口只能使用public修饰符
4、抽象类只能有一个子类，而接口可以有多个
5、抽象类可以有多个构造器，接口不能有构造器 -
public interface MyInterface {
int num = 10; //所有属性默认为：public static finalpublic void foo(); // 抽象方法是 public abstractpublic static void test(){
// jdk8 以后添加静态方法 可以直接调用}public default void test1(){
//jdk8 以后添加默认方法，通过子类调用}}
接口的定义和使用
public interface A {
//简单接口Apublic abstract void fly(); //定义一个简单的抽象方法fly();
}public class Animal {
// 父类Animalpublic void eat(){
System.out.println("吃东西");}}public class Bird extends Animal implements A{
//子类Bird 继承父类Animal， 实现接口implementspublic void fly(){
System.out.println("鸟儿飞翔"); //实现抽象方法 fly（）}public void eat(){
System.out.println("鸟儿 吃虫"); //重写eat方法}
}public class Test {
public static void main(String[] args) {
Animal b = new Bird();b.eat();Bird b1 = (Bird)b; // 子类类型子类对象名 = （子类类型） 父类对象;//向下转型b1.fly();b1.eat();}
}//运行结果：
/* 鸟儿 吃虫 鸟儿飞翔 鸟儿 吃虫 /