漫漫Java学习路,第七天

package cn.tedu.oop;
//本类用于测试代码块
public class TestBlock {
    public static void main(String[] args) {
        //System.out.println(666);//如果只是业务操作,没有创建对象,是不会执行构造方法的
        Pig p1 = new Pig();
        Pig p2 = new Pig("真香");
        Pig p3 = new Pig("甜菜根",3);
        System.out.println(p3.food);
        System.out.println(p3.age);
        p3.eat();
    }
}
class Pig{
    String food;
    int age;
    public Pig(){
        System.out.println("给我翻译翻译,什么叫惊喜!");
    }
    public Pig(String s){
        System.out.println("翻译翻译,什么叫TMD惊喜!!"+s);
    }
    public Pig(String food, int age) {
        this.food = food;
        this.age = age;
        System.out.println("什么TMD叫TMD惊喜,翻译翻译!!!");
    }
    public void eat(){
        System.out.println("小猪黄曲霉素中毒了");
        {/*局部代码块:{}
         *1.位置:方法里
         *2.执行时机:调用局部代码块所处的方法时才会执行
         *3.作用:用于控制变量的作用范围,变量的作用范围越小越好*/
            System.out.println("红烧也不错");
        }
    }

    {/*构造方法块:{}
     *1.位置:类里方法外
     *2.执行时期:每次创建对象时都会执行构造代码块,并且构造代码块优先于构造方法执行
     *3.作用:用于提取所有构造方法的共性功能*/
        System.out.println("小猪被做成烤乳猪了~");
        System.out.println("烤乳猪真好吃");
    }
}

package cn.tedu.oop;
//定义一个猫类
public class TestCat {
    public static void main(String[] args) {
        Cat c1 = new Cat();
        c1.setName("哆啦A梦");
        c1.setAge(300);
        c1.setKind("机器猫");
        c1.setHost("野比大雄");
        c1.setPrice(10000);
        System.out.println(c1.getName());
        System.out.println(c1.getAge());
        System.out.println(c1.getKind());
        System.out.println(c1.getHost());
        System.out.println(c1.getPrice());
        Cat c2 = new Cat("罗小黑",7,"猫妖","小白",800);
        System.out.println(c2.getName());
        System.out.println(c2.getAge());
        System.out.println(c2.getKind());
        System.out.println(c2.getHost());
        System.out.println(c2.getPrice());
        Cat c3 = new Cat
                ("罗青青",9000,"九命猫妖","无量天尊",100000);
        c3.eat(3);
        c3.jump("罗睺");
        c3.sleep("朱厌",20);
        c3.play("通天教主");
    }
}
class Cat{
    private String name;
    private int age;
    private String kind;
    private String host;
    private double price;
    {
        System.out.println("又来了一只喵星人");
    }
    public Cat(){
        System.out.println("十个橘猫九个胖");
    }
    public Cat(String name, int age, String kind, String host, double price) {
        this.name = name;
        this.age = age;
        this.kind = kind;
        this.host = host;
        this.price = price;
        System.out.println("奶牛猫,猫中哈士奇");
    }
    public void eat(int n){
        System.out.println("橘猫今天要吃"+n+"个鱼罐头");
    }
    public void jump(String name){
        System.out.println("奶牛猫"+name+"表演了个'乌鸦坐飞机'");
    }
    public void sleep(String name,double num){
        System.out.println("橘猫"+name+"今天一共睡了"+num+"个小时");
    }
    public String play(String host){
        System.out.println("奶牛猫与主人"+host+"玩的很开心");
        bark();
        return "逗猫棒";
    }
    private void bark(){
        System.out.println("奶牛猫喜欢喵喵叫");
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getKind() {
        return kind;
    }
    public void setKind(String kind) {
        this.kind = kind;
    }
    public String getHost() {
        return host;
    }
    public void setHost(String host) {
        this.host = host;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
}

package cn.tedu.oop;
//本类用于测试构造方法
public class TestConstructor {
    public static void main(String[] args) {
    Person p = new Person();
        /*1.每一个类中默认都会存在一个没有参数的构造方法
         * 每次(new)实例化对象时,都会自动触发这个类对应的构造方法来帮我们创建对象*/
        System.out.println(p.name);
        System.out.println(p.age);
        System.out.println(p.address);
        p.eat();
        /*3.每次创建对象时,都会执行构造方法
        * 构造方法的作用:用来创建对象的*/
        Person p2 = new Person();
        Person p3 = new Person(666);
        Person p4 = new Person
                ("齐天大圣孙悟空",73,"东胜神洲傲来国花果山水帘洞");
        System.out.println("我是"+p4.address+p4.name+",今年"+p4.age);
        System.out.println(p3.name);
        System.out.println(p3.address);
        System.out.println(p3.age);
    }
}
class Person{
    String name;
    int age;
    String address;
    /*2.构造方法的格式:没有返回值类型,并且与本类类名同名的方法*/
    public Person(){
        /*4.如果提供了其它的构造函数,默认的无参构造会被覆盖,就不存在了
        * 所有,如果想不传参数创建对象的话,就需要我们手动提供这个类的无参构造*/
        System.out.println("我是一个会自己动的无参构造");
    }
    public Person(int n){
        System.out.println("我是一个成熟的含参构造,我真是"+n);
    }
    //创建本类的全参构造
    public Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
        System.out.println("我是一个毫不起眼的全参构造");
    }

    public void eat(){
        System.out.println("干饭人,干饭魂,干饭人干饭得用盆~");
    }
}

package cn.tedu.oop;
//本类用于测试构造方法
public class TestConstructor2 {
    public static void main(String[] args) {
    Student s1 = new Student();
    Student s2 = new Student("哈哈哈");
    Student s3 = new Student("张三",'男',"抬杠",100);
        System.out.println(s3.name);
        System.out.println(s3.gender);
        System.out.println(s3.major);
        System.out.println(s3.score);
    }
}
class Student{
    String name;
    char gender;
    String major;
    double score;

    public Student(){
        System.out.println("我是Student类的无参构造");
    }
    public Student(String s){
        System.out.println("我是Student类的含餐构造"+s);
    }
    public Student(String name, char gender, String major, double score) {
        this.name = name;
        this.gender = gender;
        this.major = major;
        this.score = score;
        System.out.println("我是Student类的全参构造");
    }
}

package cn.tedu.oop;
//本类用于uoop综合练习
public class TestTeacher {
    public static void main(String[] args) {
        Teacher t = new Teacher();
//        t.name = "童渊";
//        t.age = 73;
//        t.gender = "男";
//        t.salary = 156;
//        System.out.println(t.name);
//        System.out.println(t.gender);
//        System.out.println(t.age);
//        System.out.println(t.salary);
        t.setName("孔子");
        t.setGender("老夫子");
        t.setAge(74);
        t.setSalary(123);
        System.out.println(t.getName());
        System.out.println(t.getGender());
        System.out.println(t.getAge());
        System.out.println(t.getSalary());
        Teacher t1 = new Teacher("菩提老祖","仙人",350000,200);
        System.out.println(t1.getName()+t1.getGender()+t1.getAge()+t1.getSalary());
    }
}
class Teacher{
    private String name;
    private String gender;
    private int age;
    private double salary;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public Teacher(){
        System.out.println("老师脑壳疼");
    }
    public Teacher(String name, String gender, int age, double salary) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.salary = salary;
        System.out.println("学生皮的很");
    }
}

package cn.tedu.oop2;
//本类用于继承的入门案例
public class TestExtends {
    public static void main(String[] args) {
        Fruit f = new Fruit();
        Apple a = new Apple();
        HFS h = new HFS();
        /*3.继承相当于是子类将父类的资源复制了一份
        * 继承还具有传递性,爷爷的功能会传给爸爸,爸爸的功能会传给孙子*/
        f.eat();
        a.eat();
        h.eat();
        h.sweet();
    }
}
/*1.我们通过extends关键字建立子类与父类的继承关系,格式:子类 extends 父类*/
/*2.java只支持单继承,一个子类只能有一个父类,但是一个父类可以有多个子类*/
class Fruit{
    public void eat(){
        System.out.println("食我大蕉~");
    }
}
/*6.继承是一种is a 的关系,比如苹果是一种水果,红富士是一种苹果
* 继承要求子类必须是父类的一种下属类型,依赖性非常强,强耦合*/
class Apple extends Fruit{
        int a = 10;
        private int b = 100;
}
class HFS extends Apple{
    /*4.子类可以拥有自己独有的方法,实现功能拓展,青出于蓝而胜于蓝*/
        public void sweet(){
            System.out.println(a);
            System.out.println("蕉泥做人~");
            /*5.子类继承父类以后,可以使用父类的所有非私有资源
            * 注意:这个私有资源由于被private修饰,所以没有访问权限*/
            //System.out.println(b);
        }
}

package cn.tedu.oop2;
//本类用与测试继承中变量的使用
public class TestExtends1 {
    public static void main(String[] args) {
        new Son().study();
    }
}
class Father{
    int sum = 1;
    int count =2;
}
class Son extends  Father{
    int sum = 10;
    public void study(){
        System.out.println("good good study,day day up");
        int sum = 100;
        System.out.println(sum);
        System.out.println(this.sum);
        System.out.println(count);
        /*当父类的成员变量与子类的成员变量同名时,可以用super关键字指定父类的成员变量
        * 我们可以把super看做是父类的对象:Father super = new Father();*/
        System.out.println(super.sum);
    }
}

package cn.tedu.oop2;
/*本类用于测试继承中构造方法的使用
 * 1.子类在创建对象时,默认会先调用父类的构造方法
 * 2.原因是子类构造函数中的第一行默认存在super();---表示调用父类的无参构造
 * 3.当父类没有无参构造时,可以通过super(参数);调用父类的其他含参构造
 * 注意:子类必须调用父类的一个构造函数,不论是无参还是含参,选一个即可
 * 4.构造方法不能被继承!因为语法原因,要求构造方法的名字必须是本类类名
 * 不能在子类中出现一个父类名字的构造方法*/
public class TestExtends2 {
    public static void main(String[] args) {
        Father2 f1 = new Father2();
        Father2 f2 = new Father2("皮痒!!");
        Son2 s1 = new Son2();
    }
}
class Father2{
    public Father2(){
        System.out.println("爸爸打儿子");
    }
    public Father2(String s){
        System.out.println("三天不打,上房揭瓦!"+s);
    }
}
class Son2 extends Father2{
    public Son2(){
        //super();
        super("使点劲!!!");
        System.out.println("你是没吃饭吗?");
    }
}

package cn.tedu.oop2;
//本类用于this的测试
public class TestThis1 {
    public static void main(String[] args) {
        new Dog().eat();

    }
}
class Dog{
    int count = 666;
    int sum = 100;

    public void eat(){
        int sum = 10;
        System.out.println(sum);
        /*当你的成员变量与局部变量同名时,可以使用this关键字指定本类的成员变量
         * 如果不使用this指定,打印的就是近处的这个局部变量,就近原则*/
        System.out.println(this.sum);
        System.out.println(count);
    }
}

package cn.tedu.oop2;
//本类用于测试this的用法
public class TestThis2 {
    public static void main(String[] args) {
        Cat c1 = new Cat();
        Cat c2 = new Cat("哭唧唧");

    }
}
class Cat{
    public Cat(){
        /*表示在无参构造中调用含参构造
        * 注意:调用是单向的,不能来回双向调用,否则会死循环*/
        this("sorry,sorry");
        System.out.println("哈利波特骑着扫帚飞");
    }
    public Cat(String s){
        /*表示在含参构造中调用无参构造的功能
         *规定:this关键字必须写在构造函数的第一行*/
        //this();
        System.out.println("而我的扫帚,却只能清理垃圾堆,"+s);
    }
}