——年金波老师上课笔记
Java面向对象基础
面向对象的思想：
封装、继承、多态
1.封装：隐藏对象的属性和方法 private
2.继承：对象重用 减少代码冗余 extends
单继承 将父类的属性和方法 继承到子类中
3.多态：同一个类域（存在继承关系的类）的不同对象在调用相同方法的时候表现不同
封装：修饰符 public protected private 无 修饰属性和方法
public ：其他类可以任意访问 自己类可以访问
protected：自己访问 子父类之间 相同包下
无：自己访问 相同的包下
class Person{
String name;
}
private 只有自己能访问
private Person(){
}
public static Person newone(){
return new Person（）;
}
Person p=Person.newone();
单例模式：在整个虚拟机中只有一个类的实例
专门处理日期
java.util.Date 濒临灭绝
java.util.Calendar 不能new
//指向系统当前时间
Calendar cal=Calendar.getInstance()
//获取年份
cal.get(Calendar.YEAR);
//获取月份
cal.get(Calendar.MONTH);
extends 后只能有一个父类：
this 表示当前类的实例
this.属性
this.方法（参数）
this（）；调用构造函数
this（参数）：
方法的重载和重写
重载：在一个类内有多个相同（名字上）的方法
参数类型不同。参数个数不同。参数的顺序不同。
返回值：返回值是否相同对重载不构成影响
Person{
public void print(){}
public void print(String message){}
public void print(int level){}
}
构造函数也可以重载：
重写：发生在子类 。重新定义父类中的方法。
方法签名要跟父类相同
方法签名：返回值+方法名+方法参数（个数，顺序，类型 都相同）
super：访问父类中的属性和方法
super.父类属性
super.父类方法（参数）
super()//父类的构造器
super（参数）//调用父类的重载构造器
ch05/Father.java
package ch05;
public class Father{
protected String name;
protected int age;
public Father(){}
public Father(String name, int age){
this.name=name;
this.age=age;
}
public void print(){
System.out.println("Name :"+this.name +"\tAge :"+this.age);
}
}
ch05/Son.java
package ch05;
import java.u
public class Son extends Father{
public String[]hobby;
public Son(){}
public Son(String name, int age,String hobby []){
super(name,age);
//this.name=name;
//this.age=age;
this.hobby=hobby;
}
public void print(){
super.print();
System.out.println("Hobby:"+this.hobby);
}
public static void main(String args[]){
Son son=new Son("briup",1,new String []{"reading","gaming"});
son.print();
}
}
方法的参数传递
1.值传递：对于基本的参数类型 值拷贝（把外围的值拷贝到方法内供方法使用，对方法外的变量不构成影响）
mian(){
int a=10;
change(a);
System.out.println(a);
}
static void change(int a){
a=100;
System.out.println(a);
}
先打印出100
后打印出10
2.引用传递：地址值
Person p=new Person("test",18);
change(p);
System.out.println(p.getName());
}
static void change(Person p){
p.setName("briup")
System.out.println(p.getName());
}
都打印出briup
类的初始化：
静态初始化代码段： static {}
实例初始化代码段: {}
构造方法:
ch05/InitTest.java
package ch05;
public class InitTest{
static {
//在jvm装载类的时候调用，无论创建多少个对象，都只会被调用一个。通常用来初始化静态成员变量
System.out.println("Static block is invoked!");
}
{
//创建实例之前进行调用，先与构造器
System.out.println("Instance block is invoked!");
}
public InitTest(){
System.out.println("Constructor method is invoked!");
}
public static void main(String args[]){
new InitTest();
System.out.println("--------");
new InitTest();
}
}
接口：interface 来声明。只允许定义常量 （public static final String str="abc"）和 空方法（抽象方法,没有实现）
public interface Test {
public void test(String test);
}
接口的作用：用来描述规范，被其他的接口或者类 实现或者继承
具体的类 实现（implements） 接口（一个或者多个，多个之间用"，"分割），必须实现接口内的所有方法
接口 继承(extends) 接口
接口不能被实例化。接口在一定程度上弥补类java的单继承
抽象类：如果一个类没有完全的实现接口中的所有的方法，必须把没有实现的方法声明为抽象方法。。（abstract）
如果一个类中有一个抽象方法，那么该类必须被声明为抽象类（public abstract class）
功能更普通类是一样，抽象类可以分担子类的一本分功能
方法 实例化 创建引用
实体类： 全部实现 可以 是
抽象类： 部分实现 不可以 是
接口： 全部不实现 不可以 是
Son son=new Son();
Father son=new Son();
Son s=(Son)son；如果没有就报错：ClassCastingException
因为 Son 继承 Father
Father -> Son
抽象类 -> 继承了抽象类的具体类
接口-> 实现接口的具体类
casting： 类型转换，引用或者类类型
向上转换：不需要显示的类型转换
向下转换：要显示的强制类型转换
上：father
下：son
ch05/log.java
ch05/Baselog.java
ch05/SystemLogImoI.java
ch05/FilelogImo.java
ch05/LogTest.java
员工管理：
对于员工：cr（retravel）ud
DML insert
DDL drop
存放员工的数据结构-》queue
EmppoyeeDate{ Employee [] emArray;
create();//增加员工
find（int id）；
update 更新
delete
}
Java中类的属性和方法的访问控制
- 类没有protected和private修饰符
- 被public 修饰的类，可以被其它包中的类访问
- 没有被public 修饰的类，不能被其它包中的类访问
static修饰的方法不能访问非static变量（成员变量）
static修饰的方法不能访问非static方法（成员方法）
System.out.println("A new instance is created!");
public static void main(String args[]){
Object o1=new InstanceCounter();
Object o2=new InstanceCounter();
System.out.println("Instance count:"+count);
//重写父类方法。范围不能变小. finalize 回收对象/实例占用的资源
System.out.println("Instance will be revoled by GC!");
1.修饰类 该类不能被继承 （java.long.String 不能有子类）
2.修饰属性，改属性为常量 （程序运行期间值不能被改变的叫常量） 常量的赋值：在第一次被赋值之后，永远不能改变。常量的命名：全部大写 用下划线分隔 MAX_SIZE
StringBuffer str=new StringBuffer("abc");
str.toString()->StringBuffer->String;
StringBuilder和StringBuffer 使用方式完全相同
对象的比较：== 对于引用来说比较的地址值 。对于基本类型比较的数值
Person p1 = new Person("briup",13);
Person p2 = new Person("briup",13);
p1.equals(p2) -> true :内容相同 false ->内容不同
equals的来源：java.long.object ，默认实现相当与== ， 重写该方法完成自定义的内容比较
public boolean equals(Object obj){
if(this.getClass()!=obj.getClass())
return this.getName().equals(p1)&&this.getAge()==p1.getAge();
public static void main(String args[]){
aList.add(new Boolean(false));
aList.add(new Person("briup",false,1));
aList.add(new Person("briup-999",true,2));
public static void out(List list){
Iterator it = list.iterator();
public static void outByIndex(List list){
System.out.println("---------------------------------------");
boolean hasNext();//判断是否存在下一个元素
Set :放置不可重复的对象 有对象的equals方法（返回true）和hashCode方法（返回的int值相等）决定。
public static void main(String args[]){