Background

Java lab上面出错的几个点记录一下知识点

构造函数

构造函数本身就不能有返回值,我在写的时候本能加了个 void 结果就一直报错不知道自己错哪儿了,还是我tclll

final 用法

final标记的类不能被继承;

final标记的方法不能被子类复写;

final标记的变量(成员变量或局部变量)即为常量,只能赋值一次。
final作用,有的时候使用防止子类重写,提高效率

什么时候使用super&&强制类型转换

① 必须放在第一行;

②只能调用一个其它的构造函数。(也许可以这样理解,正是因为有了第一点,如果可以调用多个的话,那么就无法放在“第一行”,所以只能允许一次调用);

demo:

 Person test;
        Person person1=new Chinese(cName,cSex,cAge);
        showEat(person1);
        Person person2=new English(eName,eSex,eAge);
        showEat(person2);

        /********* end *********/
        // 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
        // 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
        /********* begin *********/
        Chinese cn=(Chinese)person1;
        cn.shadowBoxing();
        English en = (English)person2;
        en.horseRiding();

封装继承多态总结

package test;
/*知识点目录
1,Java继承
1.1 继承的概念
1.2 继承的特性
1.3 继承关键字
1.4 构造器
2,Java重写(Override)与重载(Overload)
2.1 重写(Override)
2.2 重载(Overload)
2.3 总结
3,Java多态
3.1 多态的实现方式
4,Java抽象类
5,Java封装
6,Java接口
*/
/* 1.1继承的概念
继承在本职上是特殊——一般的关系,即常说的is-a关系。子类继承父类,表明子类是一种特殊的父类,并且具有父类所不具有的一些属性或方法。通过 extends 关键字可以声明一个类是从另外一个类继承而来的。
*/
/* 1.2继承的特性
1).子类拥有父类非private的属性,方法;
2).子类可以拥有自己的属性和方法,即子类可以对父类进行扩展;
3).子类可以用自己的方式实现父类的方法;
4).Java的继承是单继承,这是Java继承区别于C++继承的一个特性;
5).提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系)。
*/
/* 1.3继承关键字
1).使用 extends 和 implements 来实现继承,所有的类都是继承于 java.lang.Object,当一个类没有继承的两个关键字,则默认继承Object;
2).一个子类只能拥有一个父类,所以 extends 只能继承一个类;
3).使用 implements 关键字变相的使Java具有多继承的特性,为类继承接口,可以同时继承多个接口;
4).通过super关键字来实现对父类成员的访问,用来引用当前对象的父类;
5).final 关键字
5.1) 声明类则把类定义为不能继承的,即最终类;修饰方法,则该方法不能被子类重写;定义实例变量,则变量不能被修改;
5.2) final 类的方法自动为 final方法,但实例变量不自动是 final变量。
*/
interface A{}
interface B{}
class Animal{
   public void move(){
       System.out.println("动物可以移动");
   }
   Animal(){
       System.out.println("Animal()");
   }
   Animal(int n){
       System.out.println("Animal(int)");
   }
}
final class Dog extends Animal implements A,B {
   final String name = "旺财";
   final public void finalFun(){
   }
   /* 2.1.1 重写(Override)
    1).重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变,核心重写;
    2).重写的好处在于子类可以根据需要,定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法;
    3).重写方法不能抛出新的检查异常或者比被重写方法声明更加宽泛的异常。
    */
   public void move(){
       System.out.println("狗可以跳墙");
   }
   /*2.2.1重载(Overload)
   1).重载是在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同;
   2).每个重载的方法(或者构造函数)都必须有一个独一无二的参数类型列表。
    */
   public void move(int n){
       System.out.println("这只狗可以跳"+n+"米的墙");
   }
   public String toString() {
       //1.3.1 通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。
       return "I am a Dog " + super.toString();
   }
/* 1.4 构造器
1).子类不能继承父类的构造器(构造方法或者构造函数),但是父类的构造器带有参数的,则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表;
2).如果父类有无参构造器,则在子类的构造器中用super调用父类构造器不是必须的,如果没有使用super关键字,系统会自动调用父类的无参构造器。
*/
   Dog(){
       super(300);
       System.out.println("Dog()");
   }
   Dog(int n){
       System.out.println("Dog(int)");
   }
}
class Test{
   static void testsuper(){
       System.out.println("-----testsuper----");
       new Dog();
       new Dog(1);
   }
   static void testoverride(){
       System.out.println("-----testoverride-----");
       Animal a = new Animal();
       Animal b = new Dog();
       a.move();
       /*2.1.2  重写(Override)
       1).尽管b属于Animal类型,但是它运行的是Dog类的move方法;
       2).在编译阶段,只是检查参数的引用类型。在运行时,Java虚拟机(JVM)指定对象的类型并且运行该对象的方法。
        */
       b.move();
   }
}
public class JavaDemo{
   public static void main(String[] args) {
       Test.testsuper();
       Test.testoverride();
   }
}
/* 2.1.3方法的重写规则
1).参数列表必须完全与被重写方法的相同;
2).返回类型必须完全与被重写方法的返回类型相同;
3).访问权限不能比父类中被重写的方法的访问权限更低;
4).父类的成员方法只能被它的子类重写;
5).声明为final的方法不能被重写;
6).声明为static的方法不能被重写,但是能够被再次声明;
7).子类和父类在同一个包中,那么子类可以重写父类所有方法,除了声明为private和final的方法;
8).子类和父类不在同一个包中,那么子类只能够重写父类的声明为public和protected的非final方法;
9).重写的方法能够抛出任何非强制异常,无论被重写的方法是否抛出异常,但是,重写的方法不能抛出新的强制性异常,或者比被重写方法声明的更广泛的强制性异常,反之则可以;
10).构造方法不能被重写;
11).如果不能继承一个方法,则不能重写这个方法。
*/
/*2.2.2重载规则
1).被重载的方法必须改变参数列表(参数个数或类型或顺序不一样);
2).被重载的方法可以改变返回类型;
3).被重载的方法可以改变访问修饰符;
4).被重载的方法可以声明新的或更广的检查异常;
5).方法能够在同一个类中或者在一个子类中被重载;
6).无法以返回值类型作为重载函数的区分标准。
*/
/*
重写与重载之间的区别
区别点            重载方法        重写方法
参数列表       必须修改        一定不能修改
返回类型       可以修改        一定不能修改
异常                可以修改        可以减少或删除,一定不能抛出新的或者更广的异常
访问                可以修改        一定不能做更严格的限制(可以降低限制)
总结
方法的重写和重载是Java多态性的不同表现,重写是父类与子类之间多态性的一种表现,重载是一类中多态性的一种表现。
*/
/*访问控制修饰符
Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java支持4种不同的访问权限。
默认的,也称为 default,在同一包内可见,不使用任何修饰符;
私有的,以 private 修饰符指定,在同一类内可见;
共有的,以 public 修饰符指定,对所有类可见;
受保护的,以 protected 修饰符指定,对同一包内的类和所有子类可见。
我们可以可以通过以下表来说明访问权限:
访问控制
修饰符      当前类      同一包内     子孙类      其他包
public             Y                   Y                  Y                   Y
protected      Y                   Y                  Y                  N
default           Y                   Y                  N                 N
private            Y                  N                  N                 N
*/
/*3,Java多态
多态就是同一个接口,使用不同的实例执行不同操作。
3.1 多态的实现方式 重写、接口、抽象类和抽象方法。
*/
/*4,Java抽象类
1).使用abstract class来定义抽象类,抽象类不能被实例化;
2).抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类;
3).抽象类中的抽象方法只是声明,不包含方法体;
4).构造方法,类方法(用static修饰的方法)不能声明为抽象方法;
5).任何子类必须重写父类的抽象方法,或者声明自身为抽象类。
*/
abstract class Employee{
   //抽象方法
   public abstract double computePay();
}
/*4.2继承抽象类
*/
class Salary extends Employee{
   public double computePay(){ 
       return 0;   
   }
}
/*
5,Java封装
封装(英语:Encapsulation)是指,一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。
封装的优点:
1).良好的封装能够减少耦合;
2).类内部的结构可以自由修改;
3). 可以对成员变量进行更精确的控制;
4). 隐藏信息,实现细节。
实现Java封装的步骤:
1). 修改属性的可见性来限制对属性的访问;
2).对每个值属性提供对外的公共方法访问。
*/
/*
6,Java接口
1).接口,在Java编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明;
2).一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类;
3).接口不能包含成员变量,除了 static 和 final 变量;
4).接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract;
5).接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final 变量;
6).接口中的方法是不能在接口中实现的,只能由实现接口的类来实现接口中的方法;
7).类在实现接口的方法时,不能抛出强制性异常,只能在接口中,或者继承接口的抽象类中抛出该强制性异常;
8).类在重写方法时要保持一致的方法名,并且应该保持相同或者相兼容的返回值类型;
9).接口的继承使用extends关键字,允许多重继承,可能定义或继承相同的方法。
*/
interface C extends A,B{}

第二次课后作业

构造器的访问权限跟方法的访问权限是一致的,跟类的访问权限不一样。
方法的访问权限public 公开权限 protected受保护的 private私有的
类的访问权限和方法的访问权限不一样
修饰类:public表示本类可以被所有类访问(可以生成对象,访问静态方法等);
private表示只能被同一个包内的程序访问.
类没有protected修饰符。
修饰方法:表示本方法可以被所有包内的程序调用.
private 只能被所在类调用。
protected 只能被所在类及其子类访问。
典型的例子:
类本身可以是public的,即可以被所有程序访问。
而这个类的构造方法可以是private的,即外部类不呢直接调用构造方法,就是说不能通过new来创建对象。
而同时这个类提供一个public的方法getInstance()来对外提供自身对象的产生过程。
最典型的例子就是单例模式,就是封装了构造方法,通过public的getInstance方法来控制每次拿到的都是统一个对象实例。

interface接口的定义关键字

默认构造函数是编译器隐含提供的一个无参构造函数,仅当类中没有定义任何构造函数时才有效。

关于构造方法调用的时间 创建对象时候使用

this只能放在第一行 两个构造函数可以递归调用

类中可以定义成员变量和成员方法,其中成员变量用于描述对象的特征,也被称作属性,成员方法用于描述对象的行为,可简称为方法。定义在类中的变量被称为成员变量,定义在方法中的变量被称为局部变量

一个类中可以定义多个空参数的构造方法吗??
可以 使用局部的知识点

package e01;

public class jvav {

    public static void main(String[] args) {    
        Outer outer=new Outer();
        Outer.Inner inner = outer.new Inner(); // 创建内部类对象
        inner.show1(); // 测试在成员内部类中访问外部类成员变量和方法
        outer.test2(); // 测试在外部类中访问内部类成员变量和方法
    }
}

//定义外部类Outer
class Outer {
    Outer(){
        System.out.println("调用了外部类的无参构造函数");
    }
    int m = 0; // 定义外部类的成员变量
    // 定义外部类成员方法
    void test1() {
        System.out.println("外部类成员方法");
    }
    // 定义成员内部类Inner
    class Inner {
        Inner(){
            System.out.println("调用了内部类的无参构造函数");
        }
        int n = 1;
        // 1、定义内部类方法,访问外部类成员变量和方法
        void show1() {
            System.out.println("外部类成员变量m="+m);
            test1();
        }
        void show2(){
            System.out.println("内部类成员方法");
        }
    }
    // 2、定义外部类方法,访问内部类变量和方法
    void test2() {
        Inner inner = new Inner();
        System.out.println("内部类成员变量n="+inner.n);
        inner.show2();
    }
}

静态方法内部不可以使用this、super等关键字

静态变量是通过“类名.变量名”“方式调用的。

A,private同一个类bai可以访问
C,public 是全局都可du以zhi访问,子类,同一个包,同一个类都可以访问)
D,protected是同一类,同一个包,子类可以访问
无修饰符号是缺省类型--default,可以在同一个类,同一个包内访问
long 的初始值是0l