杰普Java笔试_杰普Core Java课程笔记2

——年金波老师上课笔记

Java面向对象基础

面向对象的思想：

封装、继承、多态

1.封装：隐藏对象的属性和方法private

2.继承：对象重用减少代码冗余extends

单继承将父类的属性和方法继承到子类中

3.多态：同一个类域(存在继承关系的类)的不同对象在调用相同方法的时候表现不同

封装：修饰符publicprotectedprivate无修饰属性和方法

public：其他类可以任意访问自己类可以访问

protected：自己访问子父类之间相同包下

无：自己访问相同的包下

classPerson{

String name;

}

private只有自己能访问

privatePerson(){

}

publicstaticPerson newone(){

returnnewPerson();

}

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{

publicvoidprint(){}

publicvoidprint(String message){}

publicvoidprint(intlevel){}

}

构造函数也可以重载：

重写：发生在子类。重新定义父类中的方法。

方法签名要跟父类相同

方法签名：返回值+方法名+方法参数(个数，顺序，类型都相同)

super：访问父类中的属性和方法

super.父类属性

super.父类方法(参数)

super()//父类的构造器

super(参数)//调用父类的重载构造器

ch05/Father.java

packagech05;

publicclassFather{

protectedString name;

protectedintage;

publicFather(){}

publicFather(String name,intage){

this.name=name;

this.age=age;

}

publicvoidprint(){

System.out.println("Name :"+this.name +"\tAge :"+this.age);

}

}

ch05/Son.java

packagech05;

importjava.u

publicclassSon extendsFather{

publicString[]hobby;

publicSon(){}

publicSon(String name,intage,String hobby []){

super(name,age);

//this.name=name;

//this.age=age;

this.hobby=hobby;

}

publicvoidprint(){

super.print();

System.out.println("Hobby:"+this.hobby);

}

publicstaticvoidmain(String args[]){

Son son=newSon("briup",1,newString []{"reading","gaming"});

son.print();

}

}

方法的参数传递

1.值传递：对于基本的参数类型值拷贝(把外围的值拷贝到方法内供方法使用，对方法外的变量不构成影响)

mian(){

inta=10;

change(a);

System.out.println(a);

}

staticvoidchange(inta){

a=100;

System.out.println(a);

}

先打印出100

后打印出10

2.引用传递：地址值

Person p=newPerson("test",18);

change(p);

System.out.println(p.getName());

}

staticvoidchange(Person p){

p.setName("briup")

System.out.println(p.getName());

}

都打印出briup

类的初始化：

静态初始化代码段：static{}

实例初始化代码段:{}

构造方法:

ch05/InitTest.java

packagech05;

publicclassInitTest{

static{

//在jvm装载类的时候调用，无论创建多少个对象，都只会被调用一个。通常用来初始化静态成员变量

System.out.println("Static block is invoked!");

}

{

//创建实例之前进行调用，先与构造器

System.out.println("Instance block is invoked!");

}

publicInitTest(){

System.out.println("Constructor method is invoked!");

}

publicstaticvoidmain(String args[]){

newInitTest();

System.out.println("--------");

newInitTest();

}

}

接口：interface来声明。只允许定义常量(public staticfinalString str="abc")和空方法(抽象方法,没有实现)

publicinterfaceTest {

publicvoidtest(String test);

}

接口的作用：用来描述规范，被其他的接口或者类实现或者继承

具体的类实现(implements)接口(一个或者多个，多个之间用"，"分割)，必须实现接口内的所有方法

接口继承(extends)接口

接口不能被实例化。接口在一定程度上弥补类java的单继承

抽象类：如果一个类没有完全的实现接口中的所有的方法，必须把没有实现的方法声明为抽象方法。。(abstract)

如果一个类中有一个抽象方法，那么该类必须被声明为抽象类(public abstractclass)

功能更普通类是一样，抽象类可以分担子类的一本分功能

方法实例化创建引用

实体类：全部实现可以是

抽象类：部分实现不可以是

接口：全部不实现不可以是

Son son=newSon();

Father son=newSon();

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中类的属性和方法的访问控制