当前位置: 代码迷 >> 综合 >> JavaSE学习笔记(Day6)
  详细解决方案

JavaSE学习笔记(Day6)

热度:76   发布时间:2023-11-25 01:45:51.0

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();}
}//运行结果:
/* 鸟儿 吃虫 鸟儿飞翔 鸟儿 吃虫 /