java学习随笔源码day01

1、类的5大成分

/*
                    类的5大成员：
                    1、成员变量
                    2、成员方法
                    3、构造器
                    4、代码块
                    5、内部类
 */
public class _java类的成分 {
    private String name;//成员变量

    public _java类的成分() {//构造器
        System.out.println("我是构造器");
    }

    public _java类的成分(String name) {//构造器重载
        this.name = name;
        System.out.println(name+"我是构造器");
    }

    public void run(){//成员方法
        System.out.println("我是成员方法");
    }
    {
        System.out.println("我是代码块");
    }

    class InnerClass{//内部类

    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2、static关键字

/*
                            static关键字
                            有static修饰的成员，属于类本身，只有一份，直接用类名调用
 */
public class _01StaticTest {
    public static void main(String[] args) {
        StaticTest.name="哈哈";
        System.out.println(StaticTest.name);
        StaticTest.run();
    }
}
class StaticTest{
    public static String name;
    public static void run(){
        System.out.println("静态成员方法");
    }
}

3、成员方法的分类与访问

/*
                        成员方法的分类
                        1、实例成员方法--无static修饰，需用实例对象调用
                        2、静态成员方法--有static修饰，属于类本身，只有一份，需用类名调用，也可以用实例对象调用，但是不推荐
 */
public class _04成员方法的分类和访问 {
    public static void main(String[] args) {
        Student st=new Student();
        st.setName("wyx");
        st.setAge(30);

        st.inAdrr();//对象访问静态方法 不推荐使用
        st.eat();//实例对象调用实例成员方法

        System.out.println("----------------------");
        Student.inAdrr();//静态成员方法用类本身调用
    }
}
class Student{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void inAdrr(){
        System.out.println("我在学习java");
    }
    public void eat(){
        System.out.println(name+"已经"+age+"岁，"+"我在吃饭");
    }

    /**
     * 获取
     *
     * @return name
     */
    public String getName() {
        return this.name;
    }

    /**
     * 设置
     *
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     *
     * @return age
     */
    public int getAge() {
        return this.age;
    }

    /**
     * 设置
     *
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }
}

4、成员方法的分类与访问2

public class Student {
    public static String schoolName="wyx";//静态成员变量
    private String name;//实列成员变量
    public static void JTFF(){//静态成员方法
        //System.out.println(name);//静态成员方法不能访问实列成员变量
        System.out.println(schoolName);//静态成员方法可以访问静态成员变量
        JTFF2();//静态成员方法可以访问静态成员方法
        //SLFF2();//静态成员方法不能访问实列成员方法
    }

    public void SLFF(){//实列成员方法
        System.out.println(name);//实列成员方法可以访问实列成员变量
        System.out.println(schoolName);//实列成员方法可以访问静态成员变量
        JTFF2();//实列成员方法可以访问静态成员方法
        SLFF2();//实列成员方法可以访问实列成员方法
    }
    public static void JTFF2(){

    }
    public void SLFF2(){//实列成员方法

    }
}

5、封装概述

/*
            封装：
            将类中的成员私有化，通过提供getter和setter方法暴露成员变量类赋值或取值
 */

    public static void main(String[] args) {
        System.out.println("Hello World");
        Student st=new Student();
        st.Study();
    }
}

class  Student{
    private String name;
    private int age;
    private char sex;

    public Student(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    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 char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    Student(){
        System.out.println("Student Hello World");
    }
    public void Study(){
        System.out.println("Student  Study");
    }
}

6、继承的概述

/*
                继承的概述
                面向对象的三大特征：封装、继承、多态
                继承是一种子类到父类的继承关系
                关键字extends
 */
public class _01ExtendsDemo {
}
class Person{

}
class Student extends Person{

}

class Animal{

}

class Cat extends Animal{

}