JAVA初学(包-继承)

1.IDEA快捷键

删除当前行  c+y
修改快捷键 settings  keymap
复制当前行到下一行  c+d
补全代码 a+/
添加取消注释 c+/
导入类:settings     Auto Import      A  O
快速格式化代码  c+a+l
快速运行程序 settings Run自定义
生成构造器  a+insert
查看类的层级关系  c+h
定位方法c+b
自动分配变量名 .var
增加模板 settings  editor Live Templates

2.包
包的作用: (1) 区分名字相同的类  (2)很好地管理类 (3)控制访问范围

用法：package 包名

本质:创建不同的文件夹保存类文件

包命名:数字字母下划线点，不能用数字开头

3.引入包：import java.....

import java.util.Scanner;//导入包中Scanner类

import java.util.*;//导入包中所有类

4.访问修饰符

public:完全公开

protected:对子类和同包中的类公开

默认：没有修饰符，向同包的类公开

private:只能类本身访问，不对外公开

ps.修饰符可以修饰类、方法、属性，但只有默认和public可以修饰类。

5.封装

(1)属性私有化

(2)公共的set，用于判断并赋值

(3)公共的get用于获取属性的值

public void setxxx(类型，参数名){//xxx:某个属性
    //加入验证部分
    属性=参数名;
}

public void getXxx(){//权限判断
    return xx;
}

6.名字在6字符内，年龄在1-120，年龄和工资不能直接查看

public class Encapsolution {//封装
    public static void main(String[] args){
        Person p=new Person();
        p.setName("Jackvgkjbhkn");
        p.setAge(200);
        p.setSal(30000);
        System.out.println(p.info());
    }
}
class Person{
    public String name;
    private int age;
    private double sal;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        if (name.length() <= 6) {
            this.name = name;
        }
        else{
            System.out.println("名字须在6字符以内");
            this.name="？？？";
        }
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age >= 1 &&age <= 120){
            this.age = age;
        }else{
            System.out.println("年龄需要在1-120");
            this.age=20;
        }
    }
    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }
    public String info(){
        return "name="+name+"age="+age+"sal="+sal;
    }
}

7.封装练习：姓名(长度2-4位)，密码六位，余额至少为20，否则给默认值

public class Encapsolution {//封装
    private String name;
    private double balance;
    private String pwd;


    //构造器
    public Encapsolution() {//无参构造器
    }

    public Encapsolution(String name, double balance, String pwd) {//有参构造器
        this.setName(name);
        this.setBalance(balance);
        this.setPwd(pwd);
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        if(pwd.length()==6) {
            this.pwd = pwd;
        }else{
            System.out.println("密码长度不对，默认为000000");
            this.pwd="000000";
        }
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        if(balance>20) {
            this.balance = balance;
        }else{
            System.out.println("余额不正确，默认为0");
            this.balance=0;
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        if (name.length() < 2 || name.length() > 4) {
            System.out.println("名字长度不对，应在2-4字符");
            this.name="无名";
        } else {
            this.name = name;
        }
    }
    public void show(){
        System.out.println("姓名"+this.name+"余额"+this.balance+"密码"+this.pwd);
    }
}

public class testEncap {
    public static void main(String[] args) {
        Encapsolution encapsolution = new Encapsolution();

        encapsolution.setName("Kaslana");
        encapsolution.setBalance(1000);
        encapsolution.setPwd("1234");

        encapsolution.show();
    }
}

 8.继承：当多个类存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法

用法：class 子类 extends 父类{}

public class jc01 {
    public String name;
    public int age;
    private int score;//共有属性
    public void setScore(int score) {
        this.score = score;
    }//共有方法
    public void show() {
        System.out.println("姓名：" + name + " 年龄：" + age + " 分数：" + score);
    }
}

public class Graduate extends jc01 {
    public void testing(){
        System.out.println("大学生" + name + "正在考高数");
    }
}

public class Pupil extends jc01 {
    public void testing(){
        System.out.println("小学生" + name + "正在考小学数学");
    }
}

public class testjc {
    public static void main(String[] args) {
        Pupil p = new Pupil();
        p.setScore(80);
        p.name="aaa";
        p.age=10;
        p.testing();
        p.show();

        Graduate g = new Graduate();
        g.setScore(100);
        g.name="bbb";
        g.age=20;
        g.testing();
        g.show();
    }
}

9.继承细节

(1)父类中私有的属性和方法子类不能直接 访问，应调用父类中公共方法

(2)子类必须调用父类的构造器，完成父类的初始化

(3)创建子类对象时，不管调用子类哪个构造器，默认情况下总会调用父类的无参构造器。如果父类没有无参构造器，则应用super()指定调用父类哪个构造器来完成初始化

(4)如果希望指定调用父类某个构造器，可以显式调用：super(参数列表)

(5)suoer()调用时，应放在构造器第一行

(6)super()和this()都必须在构造器的第一行，因此不能共存在同一个构造器

(7)java所有类都是object的子类

(8)父类构造器的调用不限于直接父类，可以追溯到object类

(9)单个子类最多继承一个父类

(10)不能滥用继承，继承必须满足is-a的关系

10.继承本质

public class jcEx {
    public static void main(String[] args) {
        Son son = new Son();
        System.out.println(son.name());
        //查找关系：子类本身，父类，父类的父类直到object类
        //前提是此属性可以访问
    }
}
class Grandpa{
    String name="爷爷";
    String hobby="打麻将";
}
class Father extends Grandpa{
    String name="爸爸";
    int age=50;
}
class Son extends Father{
    String name="儿子";
}

(1)Son son继承Father,Father继承Grandpa，Grandpa继承Object，先在方法区加载Object类、Grandpa类、Father类和Son类并有继承关系。

(2)在堆中分配地址空间给Son son(0x001),0x001中首先给父类和子类分配属性的空间,name、hobby是引用数据类型，应先在方法区常量池中分配地址，再指向此地址；age是基本数据类型，直接存在堆中。

(3)栈中的main栈存有新建的son对象，指向堆中的0x001