java面向对象的初识
面向对象
面向对象与面向过程
- 面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做
- 面向对象：强调了功能对象，以类/对象为最小单位，考虑谁来做。
举个例子：人把大象装进冰箱
面向对象的两个重要概念
类：对一类事物的描述，是抽象的、概念上的定义。
对象是实际存在的该类事物的每个个体因而也成为了实例（instance）
——面向对象的程序设计的重点是类的设计
——设计类就是设计类的成员。
二者之间的关系
对象是由类new出来的，派生出来的
类和对象的使用
- 创建类，设计类的成员
- 创建类的对象
- 通过“对象.属性”或者“对象.方法”调用对象结构
public class PersonTest{
public static void main(){
//2、创建Person的对象
Person per1 = new Person();
//3、调用属性方法
//对象.属性
per1.name = "Smith";
per1.isMale = "true";
System.out.println(per1.name);
//调用方法：对象.方法
per1.eat();
per1.sleep();
per1.speak("Japanese");
}
}
//1、创建类、设计类的成员
class Person{
//属性
String name;
int age = 1;
boolean isMale;
//方法
public void eat(){
System.out.println("人可以吃饭");
}
public void sleep(){
System.out.println("人也要睡觉");
}
publice void speak(String language){
System.out.println("人可以说话使用"+language);
}
}
类的结构之一：属性
类属性的使用
属性 成员变量VS局部变量
相同点
- 定义变量的格式：数据类型 变量名 = 变量；
- 先声明后使用
- 变量都有其对应的作用域
不同点 - 在类中声明的位置不同
属性：直接定义在类的一对{ }；
局部变量：声明在方法内，方法形参，代码块，构造器形参，构造器内部的变量 - 权限修饰符不同
属性：可以再声明属性是，指明其权限使用权限修饰符。
局部变量：不可以使用权限修饰符 - 默认初始化值的情况
属性：类的属性，根据其类型，都有默认初始化值
整形（byte,short,int,long）:0;
浮点型（float，double）：0.0；
字符型（char）：0或者’\u0000’;
布尔型（Boolean）：false；
引用数据类型（接口、类、数组）：null
局部变量：没有默认初始化值
类的结构之二：方法
方法的声明
权限修饰符 返回值类型 方法名（形参列表）{
方法体；
}
一：权限修饰符
java中规定的四种权限修饰符
权限修饰符从小到大的顺序为：
private < 缺省 < proteced < public
具体修饰范围
4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类的话，只能使用：缺省、public
二：返回值
返回值类型： 有返回值 vs 没有返回值
- 如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量：“return 数据”。
- 如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
//有返回值类型
public String getNatino(String nation){
String info = "我的国籍是"+nation;
return info;
}
//无返回值类型
public void eat(){
System.out.println("人要吃饭");
return;
}
return关键字的使用：
1.使用范围：使用在方法体中
2.作用：
① 结束方法
② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。
3.注意点：return关键字后面不可以声明执行语句。
三、方法名：
属于标识符，遵循标识符的规则和规范，“见名知意”
四：形参列表
形参列表： 方法可以声明0个，1个，或多个形参。
格式：数据类型1 形参1,数据类型2 形参2,…
五、方法体
方法体：方法功能的体现。
方法的调用
- 方法被调用一次，就会执行一次
- 没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法。
- 定义方法时，方法的结果应该返回给调用者，交由调用者处理。
- 方法中只能调用方法或属性，不可以在方法内部定义方法。
方法的重载
1.方法的重载的概念
定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
总结：
“两同一不同”:同一个类、相同方法名
参数列表不同：参数个数不同，参数类型不同
构造重载的举例
public void getSum(int i,int j){
System.out.println("1");
}
public void getSum(double d1,double d2){
System.out.println("2");
}
public void getSum(String s ,int i){
System.out.println("3");
}
public void getSum(int i,String s){
System.out.println("4");
}
如何判断是否构成方法的重载？
严格按照定义判断：两同一不同。
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！
可变个数的形参
- 声明格式：方法名(参数的类型名…参数名)
- 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
- 可变个数形参的方法与同名的方法之间，彼此构成重载
- 可变参数方法的使用与方法参数部分使用数组是一致的
- 方法的参数部分有可变形参，需要放在形参声明的最后
- 在一个方法的形参位置，最多只能声明一个可变个数形参
public void test(String[] msg){
System.out.println(“含字符串数组参数的test方法");
}
public void test1(String book){
System.out.println(“****与可变形参方法构成重载的test1方法****");
}
public void test1(String ... books){
System.out.println("****形参长度可变的test1方法****");
}
public static void main(String[] args){
TestOverloadto = new TestOverload();//下面两次调用将执行第二个test方法
to.test1();
to.test1("aa" , "bb");
//下面将执行第一个test方法
to.test(new String[]{"aa"});
}
java值的传递方式
System.out.println("***********基本数据类型：****************");
int m = 10;
int n = m;
System.out.println("m = " + m + ", n = " + n);
n = 20;
System.out.println("m = " + m + ", n = " + n);
System.out.println("***********引用数据类型：****************");
Order o1 = new Order();
o1.orderId = 1001;
Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
o2.orderId = 1002;
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
规则
基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
引用数据类型：将实参引用数据类型变量的“地址值”传递给形参
递归方法
- 递归方法：一个方法体内调用它自身。
- 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
- 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
// 例1：计算1-n之间所自然数的和
public int getSum(int n) {// 3
if (n == 1) {
return 1;
} else {
return n + getSum(n - 1);
}
}
// 例2：计算1-n之间所自然数的乘积:n!
public int getSum1(int n) {
if (n == 1) {
return 1;
} else {
return n * getSum1(n - 1);
}
}
面型对象的特征一：封装性（隐藏性）
封装性的引入：
当创建一个类的对象以后，我们通过对“对象.属性”方式对对象的属性进行赋值。这里操作主要受到属性的数据类型好存储范围的制约，但是在实际问题中，我们需要给属性赋值加入额外限制条件。这个条件就不能再属性声明是体现，我们只能通过方法限制条件的添加。同时，我们需要避免用户使用“对象.属性”的方法对属性进行赋值。则需要讲需要的属性声明为私有的（private）。
测试类
public class AnimalTest{
public static void main(String[] args){
//创建对象
Animal an1 = new Animal();
//通过对象.方法或者对象.属性赋值
an1.setAge(6);
an1.setLegs(4);
System.out.println("an1今年"+an1.getAge()+"岁,它有"+getLegs()+"腿");
}
}
创建类，设计类的成员
class Animal{
//添加属性
private int age;
private int legs;//腿的个数
//提供get和set方法
public void setAge( int age){
this.age = age;
}
public int getAge(){
return this.age;
}
public void setLegs(int legs){
this.legs = legs;
}
public int getLegs(){
return this.legs;
}
}
封装性思想代码的体现
体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
体现二：不对外暴露的私有的方法
体现三：单例模式（将构造器私有化）
体现四：如果不希望类在包外被调用，可以将类设置为缺省的。
Java规定的四种权限修饰符
1 权限从小到大顺序为：private < 缺省 < protected < public
2 具体的修饰范围：
4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类，只能使用：缺省、public
类的结构之三：构造器（或构造方法constructor）
一：构造器的作用
默认构造器的权限与类的权限相同
1.创建对象
2.初始化对象的信息
//创建对象的同时出示化对象的信息
Person p = new Person("Smith",45);
说明：
1.如果没有显示的定义的构造器的话，则系统默认提供一个空参的构造器
public Person(){};
2.定义构造器的格式：权限修饰符+类名+（形参列表）{ }；
public Person(){}
3.一个类中定义多个构造器，彼此之间构成重载
class Personal{
//属性
String name;
int age;
// 构造器
public Person(){}
public Person(String name){
this.name = name;
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
}
以上三个Person构造器构成重载
4.一旦我么显示的定义类的构造器之后，系统就不在提供默认的构造器；
5.一个类至少有一个构造器。
this关键字的使用
1.this可以用来修饰、调用：属性，方法，构造器
2.this修饰属性和方法
- this理解为：当前对象 或 当前正在创建的对象；
- 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是， 通常情况下，我们都择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
3.this调用构造器
①我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器；
② 构造器中不能通过"this(形参列表)“方式调用自己；
③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)”；
④ 规定："this(形参列表)“必须声明在当前构造器的首行；
⑤ 构造器内部，最多只能声明一个"this(形参列表)”，用来调用其他的构造器。
public Person(){
}
public Person(int age){
this();
this.age = age;
}
public Person(String name,int age){
this(age);
this.name = name;
}
面向对象的特征二：继承性
一：继承性的优点
1减少了代码的冗余，提高了代码的复用性；
2.便于功能扩展；
3.为之后多态性的使用做铺垫。
二：继承性的格式：
class A extends B{ }
A:子类、派生类、subclass;
B:父类、超类（Object）、基类、superclass
- 定义一个manKind类包括成员变量int sex和int salary；方法voidmanOrwoman();根据sex的值显示“man(sex==1)” 或者“job(salary!=0)”
- 定义kinds继承manKind，并包括成员变量int yearsOld；方法printAge（）打印printAge的值；
- 定义kindsTest 在类main方法中实例化kids对象somekid，用该对象访问父类的成员变量及方法；
ManKind.java
/**定义一个Mankind类包括成员变量int sex和int salary;
方法 void manOrWoman();
根据sex的值显示“man（sex==1）”或者“job(salary!=0”
*/
public class Mankind{
//属性
private int sex;//性别
private int salary//薪资
//构造器
public Mankind(){
}
public Mankind(int sex, int salary){
this.sex = sex;
this.salary = salary;
}
//方法
public void manOrWoman(){
if(sex==1){
System.out.println("man");
}else if(sex ==0){
System.out.println("woman");
}
}
public void employed(){
String jobInfo = (salary==0)? "no job" : "job";
System.out.println(jobInfo);
}
}
Kids.java
/**
定义kinds继承manKind，并包括成员变量int yearsOld；方法printAge（）打印printAge的值；
*/
public class Kids extends ManKid{
//属性
private int yearsOld;
//无参构造器
public Kids(){
}
public Kids(int yearsOld){
this.yearsOld = yearsOld;
}
//方法
public void printAge(){
System.out.println("I am"+yearsOld+"years old.");
}
/**
重新定义employed()方法，覆盖父类ManKind中定义的employed()方法
输出“Kids should stady and no job”
*/
public void employed(){
System.out.println("kids should stady and no job");
}
}
KIdsTest.java
/**
定义kindsTest 在类main方法中实例化kids对象somekid，用该对象访问父类的成员变量及方法；
*/
public class KidTest{
public static void main(String[] args){
//实例化对象
Kid someKind = new Kids(12);
someKid.pringAge();
//访问成员变量
someKid.setSalary(0);
someKid.setSex(1);
//访问方法
someKid.employed();
someKid.manOrWoman();
}
}
三：子类继承父类之后的不同点
1.体现：一点子类A继承了父类B之后，子类A就获取了父类B中声明的所有属性和方法；
特殊：父类中声明了private的属性或者方法，子类继承父类之后，仍获取了父类中私有的结构。只受封装性的影响，是的子类不能直接调用父类的结构。
2.子类继承父类之后，还可以声明自己特有的属性和方法，实现功能扩展；
3.子类和父类不同于集合和子集的关系；
4.extends:延伸、扩展。
四：java中继承性的特点
1. 一个类可以被多个子类继承；
2. java中一个类的单继承性：一个类只能有一个父类；
3. 子类是相对的概念；
4. 子类直接继承父类，称为直接父类。间接继承的父类称为：间接父类；
5. 子类继承父类之后，就获取了直接父类或者间接父类中的属性和方法。
五：超类（java.lang.Object）的理解
- 如果我们没有显示的设置一个类的父类的话，则此类继承了java.lang.Object类；
- 所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类；
- 意味着，所有的java类具有java.lang.Object类声明的功能。
方法的重写
一：什么是方法的重写
子类继承父类之后，可以对父类重名的同名同参数的方法，进行覆盖
二：方法重写和重载的区别
**重载：**在同一个类中允许存在一个以上的同名方法，只需要他们的参数个数或者参数类型不同；不具有多态性
**重写：**子类继承父类之后，可以对父类重名的同名同参数的方法，进行覆盖。表现为多态性。
三：重写的规定
方法声明：
权限修饰符 返回值类型 方法名（形参列表） throws 异常类型{
方法体
}
- 子类重写的方法的方法名和形参列表与父类的方法名和形参列表相同；
//父类
public void eat(){
System.out.println("小猫喜欢吃饭");
}
//子类
public void eat(){
for(int i = 0;i<100；i++){
System.out.println("小花猫和小狗很喜欢吃饭");
}
}
- 子类重写的方法的权限修饰符不小于父类被重写的方法权限修饰符；
//父类
public void eat(){
System.out.println("小猫喜欢吃饭");
}
//子类
public void eat(){
for(int i = 0;i<100；i++){
System.out.println("小花猫和小狗很喜欢吃饭");
}
}
//报错
void eat(){
for(int i = 0;i<100；i++){
System.out.println("小花猫和小狗很喜欢吃饭");
}
}
注意：子类不能重写父类中声明为private权限的方法；
- 返回值类型
- 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值只能是void；
- 父类被重写的方法的返回值是A类型，字子类重写的方法的返回值类型可以是A类型或A类型的子类型；
//父类
public object info(){
return null;
}
//子类
public String info(){
return null;
}
-
父类被重写的方法的返回值类型是基本数据类型，则子类重写的方法的返回值类型必须是想通的基本数据类型；
-
子类重写的方法抛出的异常类型不大于父类被重写方法抛出的异常类型；
public class A{
public void methodA() throws IOEXception{
}
}
public class B1 extends A{
public void methodA() throws FileNotFoundExceprion{
}
}
public class B2 extends A{//报错
public void methodA() throws Exception{
}
}
super关键字的使用
- super理解为：父类
- super可以用来调用：属性、方法、构造器
- super的使用：调用属性和方法
- 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
- 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
- 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。
- super调用构造器
- 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
- "super(形参列表)"的使用，必须声明在子类构造器的首行！
- 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现
- 在构造器的首行，没有显式的声明"this(形参列表)“或"super(形参列表)”，则默认调用的是父类中空参的构造器：super()
- 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器。
面向对象的特征三：多态性
理解事物的多态性：事物的多种形态；
对象的多态性：父类的引用指向子类的对象。
//父类person,子类man,woman
Person p1 = new Man();
Person p2 = new Woman();
多态性的使用：虚拟方法的调用，有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写的方法。
编译看左边，运行看右边
多态性的使用前提
①类的继承关系
②方法的重写
//测试类
public class AnimalTest{
public static void main(String[] args){
//创建对象实例
AnimalTest test = new AnimalTest();
test.fun(new Dog);
test.fun(new Cat());
}
public void fun(Animal animal){
animal.eat();
animal.shout();
if(animal instanceof Dog){
Dog d = (Dog)animal;
d.watchDoor();
}
}
}
//创建类、设计类的成员
public class Animal{
public void eat(){
System.out.println("动物吃东西");
}
public void shout(){
System.out.println("动物大声叫");
}
}
//继承了Animal
public class Dog extends Animal{
//重写了animal中的方法
public void eat(){
System.out.println("狗吃骨头");
}
public void shout(){
System.out.println("汪汪汪！");
}
public void watchDoor(){
System.out.println("看门");
}
}
public class Cat extends Animal{
public void eat(){
System.out.println("小猫爱吃鱼");
}
public void shout(){
System..out.println("喵喵喵!");
}
}
向下转型
有了多态性以后，内存中实际上是加载了子类特有的属性和方法，由于变量声明为父类类型导致编译水只能调用父类中声明的属性和方法，子类特有的属性和方法不能调用。
instanceof 的使用
规则：
x instanceof A 检验X是否为A的对象，返回值为boolean型；
其中X 变量名----A：类；
注意：
要求x所属的类与A必须是子类和父类的关系，否则编译错误；
如果 a instanceof A返回true,则 a instanceof B也返回true.其中，类B是类A的父类。
Object类
- Object类是所有类的父类；
- 如果在类的声明中未使用extends关键字指明其父类，则默认为java.long.Object类；
- Object类中之声名了一个空参构造器；
equals和“==”操作符的区别
“==”操作符
- 可以使用在基本数据类型变量和引用数据类型变量中；
基本数据类型
int i = 10;
int j = 10;
double d = 10.0;
System.out.println(i==j);
System.out.println(i==d);
char c=10;
System.out.println(i==c);
char c1 = 'A';
char c2 = 65;
System.out.println(c1 = c2);
- 如果比较的是基本数据类型变量比较的是两个变量保存的数据是否相等（类型不一定相等）
- 如果比较的是引用数据类型类型变量比较的是两个对象的地址值是否相等，是否只想相同对象实例
- 注意：‘“==”符号使用时必须保证符号左右两边变量的类型一致，要么全是基本数据类型，要么全是引用数据类型
equals（）方法的使用
- equals是一个方法，不是运算符；
- 只适用于引用数据类型
- Object类中的equals方法和==运算符的作用是相同的，比较的是两个对象的地址值是否相同，两个对象引用的是否是一个对象实体；
- 如String、Date、File,包装类等都重写了Object中的equals方法，重写之后比较的是两个对象实体的内容是否相同，而并不是两个引用地址是否相同。
- 在自定义类中如果使用equals的话我们需要对Object中的equals方法进行重写。
基本数据类型，包装类，String三者之间的相互转换
①基本数据类型→包装类
/*
基本数据类型没有类的方法 不是对象
包装类有类的方法可调用toString（）方法
*/
int num1 = 10;
Integer in1 = new Integer(num1);
System.out.println(in1.toString());
Integer in2 = new Integer("123")
System.out.println(in2.toString());
//当不是纯数字字符串时会出异常NumberFormatExpception
Integer in3 = new Integer("123asd");
②包装类→基本数据类型（包装类是对象不可做运算，需要转成基本数据类型）
Integer = in1 = new Integer(12);
int i1 = in1.intValue();
System.out.println(i1 +1);
//JDK5.0新特性自动装箱与自动拆箱
int num2 = 10;
Integer in1 = num2;
int num3 = in1;
boolean = true;
Boolean b2 = b1;
③基本数据类型，包装类→String类型
方式一：
int num1 = 10;
String str1 = num1 +" ";
方式二：调用String的valuOf
float f1 = 12.3f;
String str2 = String.valueOf(f1);
Double d1 = new Double(12.4);
String str3 = String.valueOf(d1);
④String类型→基本数据类型，包装类（调用包装类paseXxx()方法）
//相互转换是需要注意是否全是纯数字否则会出异常NumberFormatException
String str1 = "124";
int num2 = Integer.parseInt(str1);
System.out.println(num2+1);
String str2 = "true";
boolean b1 = Boolean.paseBoolean(str2);
System.out.println(b1);
利用Vector代替数组处理：从键盘读入学生成绩（以负数代表输入结束），找出最高分，并输出学生成绩等级。
而向量类java.util.Vector可以根据需要动态伸缩。
创建Vector对象：Vector v=new Vector();
给向量添加元素：v.addElement(Object obj); //obj必须是对象
取出向量中的元素：Object obj=v.elementAt(0);
注意第一个元素的下标是0，返回值是Object类型的。
计算向量的长度：v.size();
若与最高分相差10分内：A等；20分内：B等；
30分内：C等；其它：D等
import java.util.Scanner;
import java.util.Vector;
public class ScoreTest {
public static void main(String[] args) {
//1.实例化Scanner，用于从键盘获取学生成绩
Scanner scan = new Scanner(System.in);
//2.创建Vector对象：Vector v=new Vector();相当于原来的数组
Vector v = new Vector();
//3.通过for(;;)或while(true)方式，给Vector中添加数组
int maxScore = 0;
for(;;){
System.out.println("请输入学生成绩（以负数代表输入结束）");
int score = scan.nextInt();
//3.2 当输入是负数时，跳出循环
if(score < 0){
break;
}
if(score > 100){
System.out.println("输入的数据非法，请重新输入");
continue;
}
//3.1 添加操作：：v.addElement(Object obj)
v.addElement(score);//自动装箱
//4.获取学生成绩的最大值
if(maxScore < score){
maxScore = score;
}
}
//5.遍历Vector，得到每个学生的成绩，并与最大成绩比较，得到每个学生的等级。
char level;
for(int i = 0;i < v.size();i++){
Object obj = v.elementAt(i);
int score = (int)obj;
if(maxScore - score <= 10){
level = 'A';
}else if(maxScore - score <= 20){
level = 'B';
}else if(maxScore - score <= 30){
level = 'C';
}else{
level = 'D';
}
System.out.println("student-" + (i+1) + " score is " + score + ",level is " + level);
}
}
}
static关键字
static可以用来修饰：属性、方法、代码块、内部类
①用static修饰属性可分为静态属性或者非静态属性（即实例变量）
修饰实例变量
我们创建了类的多个对象，每个对象都独立的拥有一类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
静态变量
我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
static修饰属性的注意点
- 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用；
- 静态变量的加载要早于对象的创建。；
- 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
②用static修饰方法
- 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用；
- 非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
//static关键字的使用
public class CircleTest {
public static void main(String[] args) {
Circle c1 = new Circle();
Circle c2 = new Circle();
Circle c3 = new Circle(3.4);
System.out.println("c1的id：" + c1.getId() );
System.out.println("c2的id：" + c2.getId() );
System.out.println("c3的id：" + c3.getId() );
System.out.println("创建的圆的个数为：" + Circle.getTotal());
}
}
class Circle{
private double radius;
private int id;//自动赋值
public Circle(){
id = init++;
total++;
}
public Circle(double radius){
this();
this.radius = radius;
}
private static int total;//记录创建的圆的个数
private static int init = 1001;//static声明的属性被所有对象所共享
public double findArea(){
return 3.14 * radius * radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public int getId() {
return id;
}
public static int getTotal() {
return total;
}
}
单列设计模式
所谓单列设计模式，就是采取一定的方法保证整个软件系统中，对某个类之能存在一个对象实例的实现。
单列设计模式分为懒汉式和饿汉式
饿汉式
- 私有化类的构造器
- 创建类的静态的对象
- 提供公共静态的方法返回类的对象
- 要求对象实例声明为静态的
class Bank{
//1.私有化构造器防止用户创建对象实例和4. 要求对象实例声明为静态的
//2.创建类的静态的对象
private static Bank instance = new Bank();
// 3提供公共静态的方法返回类的对象
public static Bank getInstance(){
return instance;
}
}
懒汉式
- 私有化类的构造器
- 创建类的静态的对象，不初始化
- 提供公共静态的方法返回类的对象
- 要求对象实例声明为静态的
class Bank{
//1.私有化构造器防止用户创建对象实例和4. 要求对象实例声明为静态的
//2.创建类的静态的对象
private static Bank instance = null;
// 3提供公共静态的方法返回类的对象
public static Bank getInstance(){
if(instance == null){
instance = new Bank();
}
return instance;
}
}
懒汉式与饿汉式的区别：
饿汉式：线程安全但是对象实例加载时间过长；
懒汉式：延迟创建对象，线程不安全。
类的成员代码块
代码块的作用：用来初始化类、对象，只能会用static修饰
分为静态代码块和非静态代码块
1. 静态代码块
- 内部可以有输出语句；
- 随着类的加载而执行,而且只执行一次；
- 作用：初始化类的信息；
- 如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行；
- 静态代码块的执行要优先于非静态代码块的执行；
- 静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构。
2. 非静态代码块 - 内部可以有输出语句；
- 随着对象的创建而执行；
- 每创建一个对象，就执行一次非静态代码块；
- 作用：可以在创建对象时，对对象的属性等进行初始化；
- 如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行；
- 非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法。
final关键字
- final可以用来修饰的结构：类、方法、变量；
- final 用来修饰一个类:此类不能被其他类所继承；
- final 用来修饰方法：表明此方法不可以被重写；
- final 用来修饰变量：此时的"变量"就称为是一个常量；
- final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化；
- final修饰局部变量：表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
- static final 用来修饰属性：全局常量
抽象类和抽象方法
一：抽象类
用abstract修饰的类称为抽象类
- 此类不能实例化;
- 抽象类中一定有构造器，便于子类实例化时调用;
- 提供抽象类的子类，让子类对象实例化.
二：抽象方法
用abstract修饰的方法称为抽象方法
① 抽象方法只有方法的声明，没有方法体
pubic abstract eat();
② 包含抽象方法的类，一定是一个抽象类，抽象类中可以没有抽象方法。
③若子类重写了父类中的所有的抽象方法后，此子类方可实例化若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰
注意
abstract不能用来修饰属性和构造器，并且不能用来修饰私有方、法静态方法、final方法和final的类。
接口interface
接口的使用
- 接口用interface来定义
- java中接口和类是并列的两个结构
- 如何定义接口
JDK7及以前只能 定义全局常量和抽象方法；
全局常量：public static final可以省略；
抽象方法：public abstract；
JDK8接口新规范：
①定义了静态方法，只能通过接口来调用无法通过实现类来调用；
②通过实现类的对象，可以调用接口中的默认方法。如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
public default void method(){ }
③如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。–>类优先原则。
④如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错。–>接口冲突。这就需要我们必须在实现类中重写此方法。
4.接口中不能定义构造器的，接口不可实例化；
5.ava开发中，接口通过让类去实现(implements)的方式来使用。
如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化；
如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
6. Java类可以实现多个接口 —>弥补了Java单继承性的局限性；
格式：class AA extends BB implements CC,DD,EE；
7. 接口与接口之间可以继承，而且可以多继承；
8. 接口的具体使用，体现多态性；
9. 接口，实际上可以看做是一种规范；
成员内部类
一： Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
二：内部类的分类：成员内部类（静态、非静态） vs 局部内部类(方法内、代码块内、构造器内)
三：如创建成员内部类的对象(通过外部对象调用内部结构)
1静态成员内部类的创建
Person.Dog dog = new Person.Dog();
2非静态成员内部类的创建
1.创建外部类的实例
Person p = new Person();
2.创建内部类的实例
Person.Dog dog = p.new Dog();
局部内部内的使用
public class InnerClassTest1 {
//返回一个实现了Comparable接口的类的对象
public Comparable getComparable(){
//创建一个实现了Comparable接口的类:局部内部类
class MyComparable implements Comparable{
@Override
public int compareTo(Object o) {
return 0;
}
}
return new MyComparable();
}
}