day09

0 、回顾

1. 方法封装一个功能，供别人使用，（重复使用）权限修饰符 返回值类型 方法名(参数列表) {
   //代码逻辑
   
   return 返回值 ; //是否有返回值 主要返回值类型
   }查询 根据商品名称 、类型 、价格区间、品牌查询所有商品 ：selectAll（）商品名称 ：selectByName(String name)l类型查询 ： selectByType(int id) ;。。。selectGoodsByCons(String name ,int id ,doule minPrice ,double maxPrice,String brand) ;
2. this 代表当前对象 ，可以使用在方法中 ，将来调用这个方法 ，就代表谁的对象 在构造方法使用：
   • 代表当前创建的对象
   • 在构造方法中调用其他重载的构造方法 使用 this(参数) 必须在第一行
3. 构造方法
   • 创建对象
   • 构造方法可以重载

4. 重载

   • 方法名相同
   • 参数 个数、类型、不同类型的顺序

     一、权限修饰符

5. Java规定的4种权限修饰符分别为：private、缺省（不写权限修饰符的默认权限）、protected、public

6. 4种权限修饰符都可以用来修饰类的内部结构：属性，方法、构造器、内部类修饰类时，只能使用：缺省、public权限修饰符是用来限制 属性 、方法、构造方法、内部类的访问

7. 四种权限修饰符的访问权限 | 修饰符 | 类内部(本类中) | 同一个包 | 不同包的子类 | 同一个工程 | | —- | —- | —- | —- | —- | | private | Yes | | | | | (缺省、default) | Yes | Yes | | | | protected | Yes | Yes | Yes | | | public | Yes | Yes | Yes | Yes |

8. 测试权限

   • 测试默认权限修饰类 package com.woniu.day09.test2;
     class Test {
     public void test01(){
     System.out.println(“test01”);
     }
     }package com.woniu.day09.test1;

import com.woniu.day09.test2.Person;
//import com.woniu.day09.test2.Test;

public class Student {
public static void main(String[] args) {
//Test t = new Test(); //在不同包中 不能使用 默认权限修饰的类

Person p = new Person();
}
}

• 测试修饰方法和属性
  • 本类中 不受任何权限的限制package com.woniu.day09.test2;

public class Person {
public int x ;
protected int y ;
int z ;
private int m ;

public void test1(){
System.out.println(“public”);
}

protected void test2(){
System.out.println(“protected”);
}

void test3(){
System.out.println(“默认”);
}

private void test4(){
System.out.println(“public”);
}

public static void main(String[] args) {
Person p = new Person();
p.test1();
p.test2();
p.test3();
p.test4();
//在本类中 可以调用任何权限修饰的方法
p.m = 1;
p.x = 2;
p.y = 3;
p.z = 4;
}
}

  - 同一包下 不同类 中 package com.woniu.day09.test2;

class Test {
public static void main(String[] args) {
Person p = new Person();
p.test1();
p.test2();
p.test3();
//p.test4(); 在同一包下 不同类中 不能访问 private

p.x = 1;
p.y = 2;
p.z = 3;
//p.m = 10;
}
}基于Person 类

  - 不同包 的子类package com.woniu.day09.test1;

import com.woniu.day09.test2.Person;
//import com.woniu.day09.test2.Test;

public class Student extends Person {
public static void main(String[] args) {

Student s = new Student();
s.test1(); //public
s.test2(); // protecked
//s.test3(); //默认的
//s.test4(); //私有
//不同包 的子类 不能访问 默认和 私有
}
}基于 Person类

  - 如果使用 private 修饰的任何 东西 只能在本类中使用 

1. 对象的创建使用构造方法

   二、封装（面向对象的三大特征之一）

   1.封装的定义
   封装就是将对象的信息（属性）和实现细节隐藏，不允许外部直接进行访问。对外 提供接口来访问或者修改对象内部的数据，通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想
   2.封装的实现
   修改属性的可见性来限制对属性的访问，并为每一个属性创建一对取值（getter）和赋值（setter）方法，用于对这些属性的访问。
   Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：

• 隐藏一个类中不需要对外提供的实现细节
• 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作
• 便于修改，增强代码的可维护性

封装：简单说 就是把属性设置 私有（private），提供访问的方法 setter、getter方法，在setter和 getter方法中，我们可以对象数据进行控制
3. 封装的好处

• 良好的封装可以减少耦合
• 对成员变量进行控制，避免一些不必要的错误
• 提高数据的安全性，不允许直接通过”对象名.属性名”的方式改变某个私有的成员属性
• 类的内部实现可以自由修改，不会影响对该类属性值的赋值和读取。提高程序的可维护性。

4.封装的案例
public class Student {
//学号 、姓名、性别 、年龄 、学科 、分数
private String stuNum;
private String stuName;
private int age ;
private String sex ;
private String course;
private double score;

public String getStuNum() {
return stuNum;
}
public void setStuNum(String stuNum) {
this.stuNum = stuNum;
}
public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age < 0 || age > 200){
//System.out.println(“年龄在1—200岁之间！”);
//this.age = 18;
throw new RuntimeException(“年龄不合法，年龄只能是 1—200岁.”);
}else {
this.age = age;
}
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
if(sex.equals(“男”) || sex.equals(“女”)){
this.sex = sex;
}else {
System.out.println(“性别输入有误，只能是 男 或者 女!”);
this.sex = “男”;
}

}
public String getCourse() {
return course;
}
public void setCourse(String course) {
this.course = course;
}
public double getScore() {
return score;
}
public void setScore(double score) {

this.score = score;
}
public Student(String stuNum, String stuName, int age, String sex, String course, double score) {
super();
this.stuNum = stuNum;
this.stuName = stuName;
this.age = age;
this.sex = sex;
this.course = course;
this.score = score;
}
public Student() {
super();
// TODO Auto-generated constructor stub
}

public void printInfo(){
System.out.println(“姓名:”+this.getStuName() +”,性别:”+this.getSex() +”,年龄:”+this.getAge()+”,学科:”+this.getCourse()+”,分数:”+this.getScore());
}
}

三、JavaBean概念

JavaBean 简单说就是 一个Java类 ，在JavaBean的这个类中对类中属性方法由要求的：

1. 属性必须私有
2. 针对每一个私有属性，提供 setter和getter
3. bean中必须提供无参构造方法
4. bean中不建议有业务方法

JavaBean主要作用是提供一个 通用组件 ，
public class User {
private int id;
private String uname;
private String upass;
private int age;
private String tel;

public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public String getUpass() {
return upass;
}
public void setUpass(String upass) {
this.upass = upass;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getTel() {
return tel;
}
public void setTel(String tel) {
this.tel = tel;
}
public User() {
super();
// TODO Auto-generated constructor stub
}
public User(int id, String uname, String upass, int age, String tel) {
super();
this.id = id;
this.uname = uname;
this.upass = upass;
this.age = age;
this.tel = tel;
}
}
业务类 操作JavaBean:
public class UserDao {

public void addUser(User user){
//把user 对象中的数据 插入到数据库
}

public void modifyUser(User user){
//按照user 对象的参数 到数据库中修改我们的用户数据
}

public void removeByKey(int id){

//根据ID删除一个用户数据
}

public List selectAll(){
//查询所有的数据

return null;
}
}

四、package和import

1.package

包 ：就是在我们醒目里创建的不同的文件夹 ，进行分别别类的存储 Java文件
语法 ：
//包一定在我们java文件的第一行代码
//包的命名 一般使用 公司域名的反写 目的是包名不会冲突 包名使用小写字母
pacakge xx.xxx.xxxx.Xxxx ;
包的作用:

• 包帮助管理大型软件系统：将功能相近的类划分到同一个包中
• 包可以包含类和子包，划分项目层次，便于管理 （MVC）
• 解决类命名冲突的问题
• 控制访问权限

例如MVC架构模式 ：

• 控制层 controller
• 业务访问层 service
• 数据访问层 dao

com.woniuxy.k15
controller 控制层
service 业务层
dao 数据访问层
entity 实体包
utils 工具包
exceptions 异常包
intercepters 拦截器包
JDK中主要的包介绍:
1.java.lang——包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能
java.lang包中的类在使用时 不需要引入
2.java.net——包含执行与网络相关的操作的类和接口。
3.java.io——包含能提供多种输入/输出功能的类。
4.java.util——包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
5.java.text——包含了一些java格式化相关的类
6.java.sql——包含了java进行JDBC数据库编程的相关类/接口
7.java.awt——包含了构成抽象窗口工具集（abstractwindowtoolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)

2.import

在使用除了java.lang包以外，其他任何包的类的时候 ，都需要把类引入导当前类中 。
语法 ：
// 是在包 下面 类的上面
import xxxx.xxxx.xxx. ;
//或者 . 是到*号 前面的包中 搜索 相应的类
import xxxx.xxxx.xxx.Xxxxx ;
//导入具体的类 直接引入
随堂练习 ：
创建一个java类 ，Person 属性 ：pid、pname、sex、age、birth

1. 封装所有属性
2. 给所有属性提供set、get方法
3. 年龄只能在18—45之间
4. 提供无参构造方法 通过无参构造方法创建对象 并且使用set方法进行赋值 然后利用get方法获取到每一个属性值 ，并且打印出来
5. 提供 全参 构造方法 利用全参构造方法创建对象 并且取出所有属性值 打印出来

   五、static

   在类中定义变量时 ：成员变量分为两类 ：

• 实例变量 不是被static修饰的变量叫实例变量 跟随对象而产生，属于对象专有 ，不被所有对象共享
• 类变量被static关键词修饰 ，属于类的全局变量，是被所有对象共享 ，使用时使用类名进行调用public class Circle {
  //属于Circle这个类的 属于所有对象共享
  static double PI = 3.14;
  
  public double r ;
  
  public void setR(double r) {
  this.r = r;
  }
  public double getR() {
  return r;
  }
  
  public Circle() {
  // TODO Auto-generated constructor stub
  }
  
  public Circle(double r){
  this.r = r;
  }
  
  public double zhouchang(){
  return 2this.getR() Circle.PI;
  }
  
  public double area(){
  return this.getR()this.getR()Circle.PI;
  }
  }

static 除了修饰变量之外，还可以修饰什么 ？

• 变量
• 修饰方法属于全局方法，使用时也是通过类名进行调用
• 修饰代码块 在class文件被加载到虚拟机时 ，直接执行，优先执行

static关键词修饰变量、代码块加载特点:
在虚拟机加载class文件 ，直接优先被加载执行 ，而且整个程序运行期间，只会执行一次 。
在内存中 静态变量，也就是类变量只保存一份
/*
连接数据库
@author Administrator
/
public class JDBCUtil {
/
静态变量 被虚拟机优先加载 而且只加载一次 ，也只保存一份
/
static String url = “”;
static String driverClassName = “”;
static String username = “” ;
static String password = “”;

static Date date = new Date();

//定义一个代码快 进行对他们赋值
/
在虚拟机加载的时候 ，优先执行 优先于构造方法
只要class文件被加载 就执行
静态代码快的作用 ：
优先加载资源文件 只会执行一次
*/
static {
System.out.println(“1.静态代码块执行 。。。。”);
url = “jdbc:mysql://localhost:3306/k15”;
driverClassName = “com.jdbc.mysql.Driver”;
username = “root”;
password = “123456”;
}

public JDBCUtil(){
System.out.println(“2.JDBCUtil 对象被创建了。。。”);
}

public String getConnection(){
System.out.println(“3.”+url);
return “连接成功!” ;
}
}
定义静态变量 、方法 、代码块 不属于面向对象

• main方法 main方法就是静态的，只有一个 ，虚拟机加载的时候 ，优先执行main方法
• 在main执行的时候 可以从控制台接收数据 信息
• 在静态方法中 ，不能直接使用 实例变量 、也不能直接调用 静态方法

• 在静态方法中 使用 非静态变量 或者调用 非静态方法 必须使用对象 操作

  六、Date

• JDK提供的一个工具类 ，创建时间日期对象

• 构造方法 ：public Date(){}

//根据时间毫秒数 创建一个日期对象
public Date(long date){}public class TestDate {
public static void main(String[] args) {
Date d = new Date();
System.out.println(d); // 2022-03-03

int year = d.getYear(); // 过时
System.out.println(year);

//获取当前的毫秒数 从1970年1月1日
long time = d.getTime();
System.out.println(time);

long x = 1646295473258L ;
x = x - 53000 ;
//Thu Mar 03 16:17:53 CST 2022

Date d1 = new Date(x);
System.out.println(d1);
}
}

使用Date创建出来的对象 ，打印出的格式是格林威治时间格式 ，不符合我们平时看到的日期，把这个日期转换成我们想要看的日期：2022-03-03 16:38:44 2022/03/03 16:28:55
JDK提供了一个日期的格式化类 ：
//2022-03-03 16:38:44 yyyy-MM-dd
//2022/03/03 16:28:55
SimpleDateFormat
//构造方法
public SimpleDateFormat(String pattern)
public class TestSimpleDateFormat {
public static void main(String[] args) throws ParseException {

Date d = new Date();
System.out.println(d);

//定义格式化对象
SimpleDateFormat sdf = new SimpleDateFormat(“MM/dd/yyyy HH:mm:ss:SSS”);
//格式化方法 format
String sdate = sdf.format(d);
System.out.println(sdate);

//如果把字符串的日期格式 转化成 Date对象类型
String s = “2002-09-09”;
SimpleDateFormat sdf1 = new SimpleDateFormat(“yyyy-MM-dd”);
//日期的解析方法
Date d1 = sdf1.parse(s);
System.out.println(d1);
}
}

七、继承 （面向对象的第二特征）

• “继承”是面向对象中的第二特征，体现了类与类之间的“is-a”关系，当两个类进行继承关联绑定的时候，子类自动具备来自于的父类的属性和行为，做到代码的复用和设计的分离。兔子和羊属于食草动物类，狮子和豹属于食肉动物类。食草动物和食肉动物又是属于动物类。所以继承需要符合的关系是：is-a，父类更通用，子类更具体父类：定义的是通用的属性和行为 子类 ：定义各自子类中独有的属性和行为 ，不需要定义通用的属性和行为， 而是父类继承
• 继承的语法 ： ```java ● public class 父类 { }

public class 子类 extends 父类 { }

- Java中所有的类都有一个父类 。
- 在Java顶一个类 叫 Object ，所有的类如果没有显示的定义继承某个类 ，自动继承 Object类。
- 案例 ：
```java
● public class Person {
    public String name;
    protected int age ;
    String sex;
    private double height;
}
public class Teacher extends Person {
    public void printInfo(){
        System.out.println("姓名:"+this.name+",年龄:"+this.age+",性别:"+this.sex +",身高:"+this.height);
    }
}
public class Student extends Person {
    public void printInof(){
        System.out.println("姓名:"+this.name+",年龄:"+this.age+",性别:"+this.sex +",身高:"+th>is.height);
    }
}

• 从上述的案例可以看到 ，并不是父类中所哟的属性都是可以任意继承，他受到权限的控制 如果属性或者方法 ：

1. public ： 都可以继承
2. protected ：同包 或者 不同包 都可以继承
3. 默认的 ：不同的包 是不可以继承
4. private : 不可以继承

• 从上述可以看出 ，如果属性或者行为（方法）是private的就不可以继承 ，为了继承 就需要定义成 非私有的，这样又违反了封装的思想，即时这样也需要封装 ，封装之后 提供 开放的入口 ，setter 和 getter方法 ```java public class Person { private String name; private int age ; private String sex; private double height;

  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 getSex() {

    return sex;

  } public void setSex(String sex) {

    this.sex = sex;

  } public double getHeight() {

    return height;

  } public void setHeight(double height) {

    this.height = height;

  } }

public class Teacher extends Person { public void printInfo(){ System.out.println(“姓名:”+this.getName()+”,年龄:”+this.getAge()+”,性别:”+this.getSex() +”,身高:”+this.getHeight()); } } public class Student extends Person {

public void printInfo(){
    System.out.println("姓名:"+this.getName()+",年龄:"+this.getAge()+",性别:"+this.getSex() +",身高:"+this.getHeight());
}

} public class Worker extends Person{ public void printInfo(){ System.out.println(“姓名:”+this.getName()+”,年龄:”+this.getAge()+”,性别:”+this.getSex() +”,身高:”+this.getHeight()); } }

- **为什么要有继承**为了代码简洁 ，抽取公共的部分 ，封装起来 ，供所有自乐使用，扩展的时候 ，只需要扩展父类就可以
- **继承的优点缺点 ：**
- 实现代码共享，减少创建类的工作量，使子类可以拥有父类的方法和属性。
- 提高代码维护性和可重用性。
- 提高代码的可扩展性，更好的实现父类的方法
- 父类一般都是通用抽象的，抽取的都是一些子类共性的属性和方法
- 子类一般都是比较具体的，可以共享父类中非私有的属性和方法
**缺点 ：**
- 继承是侵入性的。只要继承，就必须拥有父类的属性和方法。
- 降低代码灵活性。子类拥有父类的属性和方法后多了些约束。
- 增强代码耦合性（开发项目的原则为高内聚低耦合）。当父类的常量、变量和方法被修改时，需要考虑子类的修改，有可能会导致大段的代码需要重构。
- 单继承是存在很大缺陷的，导致一个类一旦使用的继承，就不能再继承其他类来做后期扩展了。
- **Java 不支持 多继承 :**
```java
public class Worker  extends Person ,Student{
    public void printInfo(){
        System.out.println("姓名:"+this.getName()+",年龄:"+this.getAge()+",性别:"+this.getSex() +",身高:"+this.getHeight());
    }
}

• Java 支持多重继承 ：

  public class MathTeacher extends Teacher {
    public void printInfo(){
        System.out.println("姓名:"+this.getName()+",年龄:"+this.getAge()+",性别:"+this.getSex() +",身高:"+this.getHeight());
    }
  }
  public class MaleMathTeacher extends MathTeacher {
    public void printInfo(){
        System.out.println("姓名:"+this.getName()+",年龄:"+this.getAge()+",性别:"+this.getSex() +",身高:"+this.getHeight());
    }
  }

• 

    继承总结：

1. 继承的是父类中非私有是属性和方法
2. 在不同中 权限是 默认的 属性或方法 也不能继承
3. 继承只能实现单继承
4. 继承是可以进行多重继承
5. Java有一个祖宗 Object ，如果没有定义继承任何类 ，那就继承 Object 所有的类都直接或者间接的继承了 Object