JAVA教程从入门到精通 Day9

最新推荐文章于 2024-09-15 19:46:31 发布

dlogcs

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量368

点赞数

文章标签： java java-ee 开发语言

本文链接：https://blog.csdn.net/dlogcs/article/details/123539290

版权

4.11 包 package

机制：

包的信息存在于java代码的第一行类的上面
包的定义规范：com.yjxxt.xxxx
标识符规范：全部小写

作用：

方便管理众多资源
引入多重命名空间

导包：

导包指明要使用的资源的所在位置
- 使用的位置使用权限定名java.until.Scanner 只在当前位置有效
- 使用import导包在类的上面 package信息的下面一个java文件中所有类中有效
- *模糊导入模糊匹配当前包下的所有类会降低编译效率不会降低运行效率
- 静态导入只导入静态内容 import static
  - import static java.lang.Math.PI; (3.1415926……)
  - import static java.lang.Math.round; (四舍五入)
不需要导包的类：
- java.lang
- 同包下的类

范例：
package com;

import java.util.Random;
import java.util.Scanner;
//这两个就可以实现模糊导包 import java.util.*
import static java.lang.Math.PI;
import static java.lang.Math.round;

public class Test {
    public static void main(String[] args) {
        //权限定名
        java.util.Scanner sc=new java.util.Scanner(System.in);
        Scanner sa=new Scanner(System.in);
        Random sb=new Random();

        //静态变量
        System.out.println(PI);
        System.out.println(PI);
        System.out.println(PI);

        System.out.println(round(3.5));
        System.out.println(round(4.5));

        //静态方法
        System.out.println();
    }
}

class Demo{
    public static void main(String[] args) {
        //权限定名
        java.util.Scanner sc=new java.util.Scanner(System.in);
        Scanner sa=new Scanner(System.in); // 同一个包中就可以不在导包
        Random sb=new Random();
    }
}

4.11 Private 关键字

public修饰的内容可能存在安全隐患问题：

属性赋值值可能出现符合类型范围要求但是不符合业务要求的数据

private 私有的

被private关键字修饰的内容只能在本类中使用其他类中无法使用

私有属性需要配合提供一对公共的访问方式 ===>方法因为在方法中可以做逻辑判断

设置器 setter ：为私有属性设置值
访问器 getter ：获取私有属性

注意：

定义实体类时属性都需要私有化并且提供一对公共的访问方式

public class T {
    private String name;
    private int 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;
    }

    public void show(){
        System.out.println(name+"===>"+age);
    }
}

public class TDemo {
    public static void main(String[] args) {
        T sc=new T();
        sc.setAge(18);
        sc.setName("汪超");
        sc.show();
        System.out.println(sc.getAge()+","+sc.getName());
    }
}

5.12 封装

隐藏内部的实现细节对外提供公共的访问方式

优点：

提高程序的安全性
提高代码的复用性

私有是封装 √

封装是私有 ×

方法、类、属性的私有化……都是封装的体现

5.13 继承

**继承：**子继父业

**目的：**提高代码的复用性
**作用：**子类一旦继承了父类有权使用父类的成员可以在子类中定义子类独有的内容
**定义：**子类 extends 父类

**实体类|子类：**根据一系列对象抽取共性所定义的实体类

**父类：**子类的共性

子类|派生类

父类|基类|超类

特点：

单继承机制一个子类只能继承一个父类但是一个父类可以存在多个子类
修饰符只能使用public | default（默认）修饰
开闭原则===>面向对象设计原则之一：对修改关闭对扩展开放

**单继承的优点：**简单

**单继承的缺点：**不便于后期维护

class Person {
    String name;
    int age;

    public void sleep(){
        System.out.println("好好休息！！！");
    }
}


class Student extends Person {
    String id;

    public void study(){
        System.out.println(name+"好好学习！！！");
    }
}

class Teacher extends Person {
    String subject;

    public void teacher(){
        System.out.println(name+"教书育人！！！");
    }
}

public class Demo {
    public static void main(String[] args) {
        Student sc=new Student();
        sc.name="汪超";
        sc.age=18;
        sc.study();
        sc.sleep();

        Teacher ss=new Teacher();
        ss.name="胡歌";
        ss.age=39;
        ss.teacher();
        ss.sleep();
    }
}

5.14 访问权限修饰符

权限修饰符	本类	同包类	不同包下的子类	不同包下的其他类
private 私有的	√
default 默认的	√	√
protected 受保护的	√	√	√
public 公共的	√	√	√	√

注意：

都是成员修饰符只能修饰成员不能修饰局部
protected修饰的成员在不同包下的子类中需要通过继承关系使用使用子类对象
常见的两种权限：public | private
父类中私有的成员子类不能用 (如：父亲的私房钱儿子不可以使用)

package wang01;

public class Modifier {
    public String testPublic="public";
    protected String testProtested="protected";
    String testDefault ="default";
    private String testPrivate="private";

    public static void main(String[] args) {
        //测试本类中使用
        Modifier sc=new Modifier();
        System.out.println(sc.testPublic);
        System.out.println(sc.testProtested);
        System.out.println(sc.testDefault);
        System.out.println(sc.testPrivate);
    }

    //测试本类中使用
    public void test() {
        System.out.println(testPublic);
        System.out.println(testProtested);
        System.out.println(testDefault);
        System.out.println(testPrivate);
    }
}

//同包类
class Demo{
    public static void main(String[] args) {
        Modifier sc=new Modifier();
        System.out.println(sc.testPublic);
        System.out.println(sc.testProtested);
        System.out.println(sc.testDefault);
        // System.out.println(sc.testPrivate);
    }
}

package wang;

import wang01.Modifier;

//不同包下的子类
public class Modifier01 extends Modifier {
    public void test() {
        System.out.println(testPublic);
        System.out.println(testProtested);
//        System.out.println(testDefault);
//        System.out.println(testPrivate);
    }

    public static void main(String[] args) {
        //父类对象访问
        Modifier sc=new Modifier();
        System.out.println(sc.testPublic);
        //在不同包下的子类中 需要通过继承关系使用
//        System.out.println(sc.testProtested);
//        System.out.println(sc.testDefault);
//        System.out.println(sc.testPrivate);

        //子类对象访问
        Modifier01 ss=new Modifier01();
        System.out.println(ss.testPublic);
        System.out.println(ss.testProtested);
//        System.out.println(ss.testDefault);
//        System.out.println(ss.testPrivate);
    }
}

package wang;

import wang01.Modifier;

//不同包下的其他类
public class Others {
    public static void main(String[] args) {
        Modifier sc=new Modifier();
        System.out.println(sc.testPublic);
//        System.out.println(sc.testProtested);
//        System.out.println(sc.testDefault);
//        System.out.println(sc.testPrivate);
    }
}

5.15 Super 关键字

super与this 之间的区别:

this指代当前new对象
- 本类构造器的首行调用本类中的其他构造器this(参数列表)
- 区分局部与成员同名问题
  - 默认就近原则
  - 通过this.调用成员
super指代父类对象
- 子类构造器的首行通过super(参数)调用父类中的指定构造器
  - 如果没有显示通过super(参数)调用默认调用父类的空构造
- 区分子父类中同名成员
如果不存在同名问题:可以省略super.调用父类成员
- 如果存在子父类同名成员问题,同名局部问题:|
  - 默认就近原则
  - 有局部找局部
  - 通过this.找子类成员
  - 通过super.找父类成员

注意:

子父类继承关系下创建子类对象的时候其实会先父类后子类
不能在构造器的首行同时使用this(参数)与super(参数)
this与super都不能使用在静态方法中

package wang01;

public class TestSuper {
    public static void main(String[] args) {
        Zi sc=new Zi();
    }
}

class Fu{
    String str="ddd";
    public Fu(){
        System.out.println("Fu");
    }
    public Fu(int i){
        System.out.println("fufu");
    }
}

class Zi extends Fu{
    String str="fff";
    public Zi(){
        super(10);
        System.out.println("Zi");
        System.out.println(super.str);
    }
    public Zi(String s){
        System.out.println("zizi");
    }
}