java基础 （面向对象）

类

面向对象的思想：

package com.company;


/**
 *  面向对象思想：
 *      面向过程：强调每一个功能步骤
 *      面向对象：强调的是对象，然后由对象去调用
 *
*   举例洗衣服：
*       面向过程：把衣服脱下来，找一个盆，放水，放洗衣粉，跑十分钟，揉一揉，清洗，拧干，晾衣服
 *       面向对象：衣服脱下来 ，打开洗衣机，放入衣服，按钮，晾衣服
 *
 *
 * java的最基本组成是类
 *
*   类：是一组相关属性和行为的集合    学生
 *   对象：是该类事物的具体体现       张三
 *
 * 类：用来描述现实世界事物的
 * 事物：   属性   行为
 * 类：   成员变量   成员方法
 *
 * 成员变量： 与变量的小区别：
 *          1.位置不同
 *          2. 成员变量不需要给初始化值也可以使用（有默认值）
 * 成员方法：  与方法的小区别：
 *          去掉修饰符中的static关键字
 *
 *
 *  例子：定义一个学生类：
 *
 *  学生事物：
 *          属性：姓名  ，年龄..
 *          行为：学习 ， 吃饭..
 *          
 *          成员变量：姓名  ，年龄..
 *          成员方法：学习 ， 吃饭..
 *  
 * 
 */
public class Main {
    public static void main(String[] args) {

    }
}
public class Student{
    //成员变量  不需要初始值
    String name;
    int age;
    
    //成员方法   去除static
    public void study(){
        System.out.println("好好学习天天向上");
    }
    public void eat(){
        System.out.println("学习饿了要吃饭");
    }
    }

类 的组成

package com.company;


/**
 *  类
 *  创建对象  格式：
 *      类名 对象名 = new 类名（）
 *  对象 访问成员  格式：
 *      成员变量：
 *          对象名.成员变量
*       成员方法：
 *          对象名.成员方法
 *
 */
public class Main {
    public static void main(String[] args) {

        //创建对象
        Student s = new Student();

        //成员变量的使用
        System.out.println("姓名："+s.name);
        System.out.println("年龄："+s.age);

        //给成员变量赋值
        s.name = "令狐冲";
        s.age = 13;

        //成员变量的使用
        System.out.println("姓名："+s.name);
        System.out.println("年龄："+s.age);

    }
}

//私有的类
//共有的需要加 public
class Student{
    //成员变量
    String name;
    int age;

    //成员方法
    public void study(){
        System.out.println("好好学习天天向上");
    }
    public void eat(){
        System.out.println("学习饿了要吃饭");
    }
    }

全局变量和局部变量区别： private 关键字 ：

package com.company;


/**
 *  全局变量和局部变量区别：
 * 1. 位置不同
 * 2. 内存位置不同   ：全局在堆，局部在栈
 * 3. 生命周期不同   ：全局随着对象的创建而存在，局部随着方法调用而存在
 * 4. 初始化值不同	 ：全局 有默认值，局部没有默认值
 *
 *
 *
 * private 关键字 ：
 * 是一个修饰符
 * 可以修饰成员变量，也可以是成员方法
 * 被private修饰的成员只能在本类中访问
 *
 * 针对private成员变量，获取getXxx（）和 设置setXxx（）   成员变量的值
 * 方法用public修饰
 */
public class Main {
    public static void main(String[] args) {

        //创建对象
        Student s = new Student();


        //通过方法赋值
        s.setAge(30);
        s.show();

    }
}

package com.company;


public class Student{
    //成员变量
    String name;
    private int age;  //私有 不能直接访问

    public void setAge(int a){
        if(a<0 || a>200){
            System.out.println("你的年龄有误");
        }else{
            age = a;
        }
    }

    public int getAge(){
        return age;
    }

    //成员方法   缺少static
    public void study(){
        System.out.println("好好学习天天向上");
    }
    public void eat(){
        System.out.println("学习饿了要吃饭");
    }
    public void show(){
        System.out.println(name+"***"+age);
    }
}

封装：

this关键字：

package com.company;

/**
 * 封装：
 *
 * this 关键字  代表所在类的对象引用
 *
 * 用于解决成员变量被隐藏的问题
 */
public class Student{
    //成员变量
    String name;
    private int age;  //私有 不能直接访问

    public void setAge(int age){
        if(age < 0 || age >200){
            System.out.println("你的年龄有误");
        }else{
            this.age = age;
        }
    }

    public int getAge(){
        return this.age;
    }

    //成员方法   缺少static
    public void study(){
        System.out.println("好好学习天天向上");
    }
    public void eat(){
        System.out.println("学习饿了要吃饭");
    }
    public void show(){
        System.out.println(name+"***"+this.age);
    }
}

构造方法：

package com.company;

/**
 * 构造方法： 用于给对象的数据进行初始化
 *  *
 *  *  格式：
 *  *          方法名和类名相同
 *  *          没有返回值类型，void也不能写
 *  *          没有具体的返回值
 *
 *  注意事项：
 *      1. 如果没有给出构造方法，系统将给出一个默认的无参数的构造方法供我们使用
 *      2. 自己给出了构造方法，系统就不再给默认值的构造方法了（一定要自己构建一个默认值得构造函数）
 *      3. 构造方法也是可以重载的
 *
 *  给成员变量赋值的方式：
 *      1. 通过setXxx（）
 *      2. 通过构造方法
 */
public class Student{
    private String name;
    private int age;

    //构建方法
    public Student(){}

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

    public Student(int age){
        this.age = age;
    }
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void show(){
        System.out.println(name+"---"+age);
    }
}

package com.company;


public class Main {
    public static void main(String[] args) {

        //调用构造方法
        //格式 ；类名对象名= new 构造方法名（）
        Student s = new Student();
        s.show();

        Student s1 = new Student("赵四");
        s1.show();

        Student s2 = new Student(13);
        s2.show();

        Student s3 = new Student("赵四",13);
        s3.show();
    }
}

标准类的代码写法：

package com.company;

/**
 *
 */
public class Student{
    //成员变量
    private String name;
    private int age;

    //构建方法
    public Student(){}


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


    //成员方法
    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public  void setAge(int age){
        this.age = age;
    }

    public int getAge(){
        return age;
    }
}

package com.company;


/**
 *
 */
public class Main {
    public static void main(String[] args) {

        //无参构造方法   setXxx（）
        Student s = new Student();
        s.setName("赵四");
        s.setAge(30);
        System.out.println(s.getName()+"--"+s.getAge());

        //带参构造方法
        Student s2 = new Student("林青霞",30);
        System.out.println(s2.getName()+"--"+s2.getAge());

    }
}

继承

原则：就近原则
java只支持单继承

super关键字：

* super 和 this 区别
 *      this：代表本类对象的引用
 *      super：代表父类的存储空间

package com.company;

/**
 *  * super 和 this 区别
 *  *      this：代表本类对象的引用
 *  *      super：代表父类的存储空间
 *
 *  java  继承中构造方法的访问特点：
 *      1. 子类构造方法 执行前都会先执行父类无参构造方法
 *      2. 子类继承父类 会继承父类的非私有成员
 *      子类初始化的时候，可能会用到父类的数据，如果父类数据没有初始化，
 *      子类就不能继承这些数据，所以在子类初始化之前，一定要先完成父类数据的初始化
 *
 *      注意：子类的构造方法中，默认第一行有一条语句：super（）
 *
 *  假如父类没有构参发法，怎么办？
 *      1. 构造一个(建议使用这种方法)
 *      2. 用super访问父类带参构造方法
 */
public class Father {
    public Father(){
        System.out.println("Father无参构造方法");
    }

    public Father(String name){
        System.out.println("father 带参构造方法");
    }
}

package com.company;

public class son extends Father {
    public son(){
        super("林青霞");
        System.out.println("son无参构造方法");
    }

    public son(String name){
        super("林青霞");
        System.out.println("son带参构造方法");
        System.out.println(name);
    }
}

package com.company;


/**

 */
public class Main {
    public static void main(String[] args) {
        son s = new son();
        System.out.println("---------");

        son s2 = new son("linqingxia ");

    }
}

重写

package com.company;
/**
        方法重写：子类与父类中出现了相同的方发声明情况

 当子类需要父类的功能，但子类又有自己特有的功能时，就采用重写
 这样既保证了父类的功能，还添加了子类的特有功能

 @Override 这个注解标记了一个方法，表示该方法是重写父类的方法

    方法重写注意事项：
        1. 父类私有方法不能重写
        2. 子类重写父类方法时，访问权限不能更低
 */
public class Main {
    public static void main(String[] args) {
        Phone p = new Phone();
        p.call("lqx");
        System.out.println("------");
        NewPhone p2 = new NewPhone();
        p2.call("lqx");
    }

}

package com.company;

public class Phone {
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }
}

package com.company;

public class NewPhone extends Phone{
    public void call(String name){
        System.out.println("开启视频功能");
        //System.out.println("给"+name+"打电话");

        //这本分功能在父类中  已经有了，就采用重写的方法
        super.call(name);
    }
}

多态

package com.company;

/**
 *  多态  ： 同一个对象，在不同时刻体现出来的不同状态
 *  eg： 猫 是猫也是动物
 *
 *  java  中多态的前提：
 *      1. 继承
 *      2. 重载
 *      3. 父类引用指向子类对象
 *          Fu  f  = new Fu（）
 *
 *  多态好处：
 *          提高了程序的扩展性
 *          具体体现：使用父类作为参数
 *
 *      弊端：
 *          不能使用子类的特有功能
 *
 *   编译看左边，运行看右边（子类中特有功能不能使用，因为父类左边没有）
 *
*    转型：(想使用特有功能)
 *      向上转型
 *          从子到父
 *      向下转型
 *          从父到子
 */
public class Main {
    public static void main(String[] args) {
        animal a = new cat();
        a.eat();

        cat c = (cat) a;//向下转型
        c.eat();
        c.playGame();

        a = new dog();
        a.eat();

        dog d = (dog) a;
        d.eat();
        d.playGame();

    }
}

package com.company;

public class animal {
    public void eat(){
        System.out.println("吃东西");
    }
}

package com.company;

public class dog extends animal {
    public void eat(){
        System.out.println("汪汪汪");
    }
    public void playGame(){
        System.out.println("888");
    }
}

package com.company;

public class cat extends animal{
    public void eat(){
        System.out.println("喵喵叫");
    }
    public void playGame(){
        System.out.println("666");
    }
}

final关键字

/**
 *  final 是一个关键字表示最终的意思。
 *  修饰类：表名该类是最终类，不能被继承
 *  修饰变量：表名该变量是常量，不能再次被赋值
 *  修饰方法：表名该方法是最终方法，不能被重写
 */

static关键字

/**
 *  static ： 是一个关键字，静态的意思。
 *  修饰成员  特点：
 *      1. 被类中所有对象共享
 *          其实也是一个成员是否应该用static修饰的条件
 *      2.可以通过类名直接访问
 *
 *      非静态的成员方法都可以访问
 *      静态的只能访问静态的
 *
 *  注意事项：
 *  静态成员方法中不能出现   this  super关键字
 *  原因：静态十岁这类的加载而加载，this  super关键字是随着对象的创建而存在的
 *      先进内存的，不能访问后进内存的
 */

抽象类

package com.company;

/**
 *  抽象方法 abstract
 *
 *  抽象类特点：
 *          1. 抽象类和抽象方法必须使用abstract关键字修饰
 *          2. 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
 *          3. 抽象类不能实例化
 *              如何实现实例话呢？
 *                  通过多态的方法，通过子类对象实例化
*           4. 抽象类的子类
 *              要么重写抽象类中的所有抽象方法
 *              要么就该定义为 抽象类

	抽象类的成员特点：
 *      成员变量：可以是变量，可以市场量
 *
 *      构造方法：有构造方法
 *              用于子类访问父类数据的初始化
 *
 *      成员方法：
 *              有成员方法，可以是抽象的，也可以是非抽象的
 *              抽象方法：限定子类必须完成某些动作
 *              非抽象方法：提高代码的复用性（继承）
 *
 *
 */
public class Main {
    public static void main(String[] args) {
        //参照多态
        animal a = new cat();
        a.eat();
        a.sleep();
    }
}

package com.company;

public abstract class animal {
    //抽象方法
    public abstract void eat();

    //实例方法
    public void sleep(){
        System.out.println("shuijiao");
    }
}

package com.company;

public class cat extends animal {
    public void eat(){
        System.out.println("喵喵买");
    }
    public void sleep(){
        System.out.println("shuijiao");
    }
}

接口

package com.company;

/**
 *  接口特点：
 *      1. 定义接口 使用interface关键字
 *      2. 类与接口之间是实现关系，用implement关键字
 *      3. 接口不能实例化
 *          接口有没有其他的方式实例化呢？
 *          参照多态的形势  使用实现类来实例化
 *      4. 接口的实现类
 *          要么重写接口中的所有抽象的方法
 *          要么是一个抽象类
 *
 * 多态的几种形式：
 *      具体类多态（几乎不用）
 *      抽象类多态（常用）
 *      接口多态（最常用）
 
*  接口成员特点：
 *      成员变量：
 *              有成员变量，且变量只能是常量
 *              默认修饰符：public static final
 *      没有构造方法
 *
 *      成员方法：
 *              有成员方法，而且都是抽象的。
 *              默认修饰符：public abstract
 *
 *  object 是最根本的根结构
 *
 
 *	类与类：
		继承关系
	类与接口：
			实现关系
		继承一个类的同时实现多个接口
	接口与接口：
		继承关系，可以单继承，也可以多继承



 */
public class Main {
    public static void main(String[] args) {
        jumpping j = new cat();
        j.jump();
    }
}

package com.company;
// 定义了一个跳高的接口
public interface jumpping {
    //抽象方法
    public abstract void jump();

}

package com.company;

public class cat implements jumpping{

    @Override//表示重写 （因为调用的jummping有抽象方法，必须重写）
    public void jump() {
        System.out.println("猫可以调高了");
    }
}

package com.company;

/**
 *  分析从 具体到抽象
 *
 *  代码  从抽象到具体
 */
public class Main {
    public static void main(String[] args) {
        cat c = new cat();
        c.setName("加菲猫");
        c.setAge(3);
        System.out.println(c.getName()+"---"+c.getAge());
        c.eat();
        c.jump();
    }
}

package com.company;
// 定义了一个跳高的接口
public interface jumpping {
    //抽象方法
    public abstract void jump();

}

package com.company;
//抽象的动物类
public abstract class animal {
    private String name;
    private int age;

    public animal(){}

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

    }

    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 abstract void eat();
}

package com.company;

public class cat extends animal implements jumpping{

    public cat(){

    }

    public cat(String name,int age){
        super(name,age);
    }

    @Override//表示重写 （因为调用的jummping有抽象方法，必须重写）
    public void jump() {
        System.out.println("猫可以调高了");
    }

    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }

}

package com.company;


    public class dog extends animal implements jumpping{

        public dog(){

        }

        public dog(String name,int age){
            super(name,age);
        }

        @Override//表示重写 （因为调用的jummping有抽象方法，必须重写）
        public void jump() {
            System.out.println("狗可以调高了");
        }

        @Override
        public void eat(){
            System.out.println("狗吃肉");
        }
    }

抽象类和接口的区别：

1. 成员区别：
   抽象类：可以是变量，也可以是常量
   构造方法: 有
   成员方法：可以是抽象方法，也可以是非抽象方法

2. 关系区别：
   类与类：继承关系
   类与接口：实现关系，可以单实现，也可以多实现
   接口与接口：继承关系，可以单继承，也可以多继承

3. 设计理念区别：
   抽象类 被继承体现的是 is a
   接口 被实现体现的 like a

举例：
猫，动物
猫，跳高运动员

包

包：其实就是文件夹
作用：就是对类进行分类关系

导包：import
类不在同一个包下，使用的时候，要加类的全路径名称

权限修饰符