封装
匿名函数
2--匿名对象使用方式一，当对象的方法只调用一次时，可以用匿名对象完成，这样写比较简单，如果对一个对象进行多个成员必须个这个对象起个名字
3--匿名对象使用方式二，可以将匿名对象作为实际参数进行传递
4--void是一种返回类型，代表没有具体返回类型的结果，而构造函数根本不需要定义返回类型
构造函数
构造函数作用可以给对象初始化
因为现在任意一个对象，就具有基本的属性
6--构造函数小细节：当一个类没有定义构造函数是，那么系统会给类加一个空值，挡在类中自定义了构造函数后，默认的函数就没有
7--构造函数在写法上有不同，在运行上也不同构造函数在对象已建立就运行，对象初始化、而一般方法是对象调用才执行，给对象添加对象具备的功能
一个对象建立，构造函数只运行一次，而一般方法可被对象调用多次。
构造函数不可以使用return
8--什么时候该定义构造函数，当分析事务，具备以下特性或行为，那么将这些类容定义在构造函数中
构造代码块
{
System.out.println("dddddddddddddddddd");
}
构造代码块，就是没构造函数名
作用，给对象进行初始化
对象一建立就运行，优先于构造函数
构造代码块，是给所有对象进行统一初始化
二构造函数式给对应的对象初始化
构造函数是可以私有化的
This
This代表他所在函数所属对象的引用
那个对象调用this，this就代表那个对象
就单说：那个对象在调用this所在的函数，this就代表那个对象
什么时候用this当定义类中功能时，该函数内都要调用该函数的对象时，这是用this来表示这个对象。但凡本类功能使用本类对象用this表示
构造函数之间调用只能用this语句
初始化的 动作要先执行
This语句只能定义子啊构造函数的第一行，因为初始化先执行
Static
是一个静态 static 是一个修饰符修饰成员变量和方法
特点
随着类的加载而加载，也就是静态随类的消失而消失 说明他的生命周期最长
优先于对象的存在被所有对象共享可以直接被类名所共享，
实例变量生命周期岁对象消失而消失
静态方法只能访问静态成员 包括方法和变量非静态可以访问静态成员静态方法中不可以定义this和super关键字
因为静态优先于对象存在，所以静态方法中不可以出现this
静态有利有弊，利：对对象共享的数据进行单独空间存储节省内存空间，没有必要每个对象都存储一份
可以直接被类名调用
弊端：声明周期太长，访问出现局限性，静态只能范文静态
什么时候定义静态变量或类呢？
当对象中出现共享数据时，该数据被静态所修饰，该对象中的特有数据也就是说不是共享的要定义成非静态存在于堆内存中
什么时候定义静态函数呢？
当功能内部没有访问到非静态数据或对象的特有数据，那么该功能可以定义静态的
主函数定义
Public 代表该函数局限最大
Static 代表主函数随类的加载存在
Void 主函数没有具体的返回值
main 不是关键字，是一个特殊的单词 可以被jvm识别
工具类
通常情况下，工具类都是定义的静态方法
下面我们就制作这个工具栏的 说明书，通过文档注释来说明
在类文件中/**
这是一个可以对数组进操作的工具类，该类中提供了，获取最值，排序等功能；
*/
要想把一个类生存帮助文档的话，这个类必须是 公用的，也就是说必须被public所修饰
如 public ArrayTool class
静态代码块
Static {
}
对象初始化过程
先执行类中的 static代码块， 如果有的haunted，给类进行初始化
在堆内存中开辟空间，分配内存地址
在堆内存中建立对象的特有属性，并默认初始化
对属性进行显示初始化
对对象进行构造代码块的初始化
对对象进行对应的，构造函数初始化
将内存地址赋给栈内存中的变量
设计模式
单列设计模式 ：解决一个类在内存只存在一个对象
保证对象唯一性
1，为了避免其他程序过多的建立该类对象。先禁止头程序建立该类的对象
2，我了让其他程序访问该类对象，只好在本类中，自定义一个对象
3，我了方便其他程序对自定义对象的访问，可以对外提供一些访问方式
对象存在堆里面
以上三步用代码体现
1，将构造函数私有化
2，在类中创建一个本类对象
3，提供一个方法可以获取该对象
对于事物该怎么描述就怎么描述
当需要将该事物，的对象保证在内存中唯一是，就将以上三步都加上
列如代码：
//单列设计模式一：饿汉式
private static Student s=new Student();
private student(){}
public static Student getStudent()
{
return s;
}
单列设计模式二：懒汉式
class single
{
private static single s=null;
private single(){}
if(s==null)
{
//这表示只能有一个程序进来，如果其他程序进来，这就判断s不等于空，
其他程序就进不来
//如果A进来
synchronized (single.class);//这句换是要求同步执行程序
public static singlg getInstance()
{
if (s==null)
--》A//A就在这里，其他的就进不来，对多走到synchronized这里
s=new single();
return s;
}
}
}
记住 定义单列时，最好使用饿汉式。
继承
1，提高代码的复用性
2，让类与类之间产生的关系，有了这个关系，才有了多态的特性
注意
千万不要为了获取其他类的功能。为了简化代码而产生继承
必须是类与类之间有所属关系才可以继承；
在java语言中，java只支持单继承，不支持多继承。因为多继承容易带来安全隐患：当父类中定义了相同功能，当功能相同时子类不确定应用哪一个
但是java保留了这种机制，并用了另一种体现形式来完成表示，多实现、
Java支持多层继承，也就是一个继承体系，如何使用一个继承体系中的功能呢
想要使用体系，先查询体系父类的描述，因为父类中定义的是该体系中共性的功能，通过了解共性功能，就可以知道该体系的基本功能，那么这个体系就已经基本可以使用了。
在具体调用时要创建子类的对象，为什么？
1，因为父类有可能不能创建对象，
2，创建子类对象，可以使用跟多的 功能，包括基本的也有特性的。
简单一句话，就是查阅父类功能，创建子类对象的使用功能
组合--聚集关系、
子父类中变量的特点
1变量
1.如果，父类中出现非私有的成员变量时，子类要访问本类中的变量，用this
子类要访问父类中的同名变量，用super
Super和this使用几乎是一致的，this代表是本类对象的引用，super的代表父类对象的引用
子父类中的函数的特点=覆盖
当子类出现和父类一样的函数时，但子类对象调用该对象函数，
会运行子类函数的类容；
如同父类函数被覆盖一样。这种情况是函数的另一个特性，：重写（覆盖）
但子类继承父类，沿袭了父类的功能，到子类中
但子类虽然具备该功能，但是功能的内容却和父类不一致
这时，没有必要定义新功能，而是使用覆盖特殊，
保留父类的功能的定义，并重写功能类容
覆盖 注意：
子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败
覆盖必须要加关键之public
2，静态只能覆盖静态
记住
重载：只看同名函数的参数列表
重写：子父类方法一模一样，
子父类中的构造函数特点，子类实例化过程
在子类中有一个隐藏的用法就是
zi
{
Super();调用父类构造函数
Zi()
{
}
在对子类对象进行初始化是，父类 的构造函数也会运行，那是因为子类的构造函数默认第一行有一天隐藏的语句super()；
Super会访问父类的空参数的构造函数，子类所有的构造函数都有一个默认的 super（）；
为什么子类一定要访问父类的构造函数，
因为：父类中数据子类可以获取，所以子类在建立是，需先查看父类如何对这些数据进行初始化的所以子类初始化时，要先访问父类的构造函数
如果要访问父类指定的构造函数，可以通过手动定义super语句的方式来指定
Super一定要定义在子类的构造函数的第一行
子类实例化过程
结论：子类的所有的构造函数默认都会访问父类中空参数的构造函数
因为子类每一个构造函数的第一句都有一个隐藏的super（）当父类中没有空参数的构造函
数是，子类必须手动通过super或者this语句形式来指定访问父类中的构造函数，类的构造函数第一行也可以手动指定this语句来访问本类的构造函数，
子类中至少会有一个构造函数会访问父类的构造函数
}
Final
修饰类，修饰的类不可以被继承，修饰的函数不可以被覆盖
修饰的变量是一个常量，只能赋值一次
被final修饰的类不可以被继承，是为了避免被子类覆盖功能
Final class demo{
Void show();
}
//这是错误的继承
Class sub extends demo{
}
被final修饰的变量时一个常量只能赋值一次，既可以修饰成员变量又可以修饰局部变量
Final int x=9；
这是x终生为9了，不能改变
注意：当在描述事物一些数据的 出现值是固定的，这是为了增强阅读，都给这些值加上final
Final就是为了要锁定常量值
如果要共享，就在final前加static 被final定义的就必须要大写
抽象类
当多个类中出现相同功能，但功能主体不同，这是可以向上抽取，这只抽取声明的方法（定义的），不
抽取功能主体
抽象就是看不懂
抽象类的特点，
1，抽象方法，一定在抽象类中
2.抽象方法和抽象类必须被abstract所修饰
3.抽象类不可以用new创建对象，因为调用抽象方法没意义
4.抽象类方法要被使用，必须由子类复写所有抽象方法后，建立子类对象调用
5.如果子类只覆盖部分抽象方法，那么该子类还是一个抽象类
6. 抽象类可以强迫子类做一些事情
7.抽象类和一般类没有太大不同
8.该如何描述事物，就如何描述，这是在事物出现了看不懂的东西
9.这些事物功能需要明确出现，但无法定义主体，就通过抽象方法来表示，
10.抽象类比一般类多了一个抽象方法，就是在类中可以定义抽象方法，也只能定义抽象方法
11.抽象类不可以实例化，
12.特点： 抽象类中可以不定义抽象方法，这样做只是不让改类建立对象
模板方法模式
获取时间 system.currenttimemillis（）；
当代吗完成优化后，就可以解决这类问题
这种方式，模板方法设计模式
什么是模板方法
定义功能是，功能的一部分确定，但有一部分不确定，而确定的部分在使用不确定的部分那么着时就将不不确定的部分暴露了，有该类子类去完成
接口
接口：初期理解，可以理解为一个特殊的抽象类
抽象类的方法都是抽象的，那么该类可以通过接口的形式来表示
接口里面成员：全是抽象的
接口在定义时，格式
1，接口中常见定义：常量，抽象方法
接口中成员都有固定修饰符
常量：public static final
方法，public abstract
接口中的成员都是 public的
接口是不可以常见对象的，因为都是抽象方法
需要被子类实现， 子类要把接口里的抽象方法全都覆盖后，才能实例化
否则子类是个抽象类
接口可以被类多实现，
一个类在继承一个类时，还可以实现多个接口
类与接口之间的关系式实现关系
接口的特点
基本功能实现在类中，扩展功能实现在接口中
多态
多态可也理解为事物存在的 多种形态
函数也具有多态
1 多态的体系
父类的引用指向了自己的类中对象
2，多太的前提
必须是类与类之间的关系，要么继承，要么实现
通常还有一个就是存在覆盖
3 多态弊端，
提高扩展性 但是只能使用父类的引用访问父类的成员
不能使用子类的特有属性
3，多态的好处
大大的提高了程序的扩展性
多太的扩展性
abstract class Animal
{
public abstract void eat();
}
class Cat extends Animal
{
public void eat()
{
System.out.println("吃鱼");
}
public void catchMouse()
{
System.out.println("抓老鼠");
}
}
class Dog extends Animal
{
public void eat()
{
System.out.println("吃骨头");
}
public void kanjia()
{
System.out.println("看家");
}
}
public static void main(String[] args)
{
//Cat c=new Cat();
//c.eat();
function(new Cat());
function(new Dog());
function(new Cat());
}
public static void function(Animal a)
{
a.eat();
}
如果想要调用猫的 特有方法是，如何操作
强制将父类的引用，转换成子类类型
列如
Cat c= (Cat)a;
c.catchMouse();
前往不要出现将父类对象转换成子类的类型
我们能转换的是父类应指向自己的子类对象时，gia可以被提升，也可以
强制转换
多态始终都是子类对象在变化
多态成员函数非静态的特点
在编译时：引用变量所属的类中是否所有调用的方法，
如果有 编译通过，没有则，编译失败
在运行时，参阅对象所属的类中是否有调用的方法
总结：成员函数在多态调用时，编译看左边，运行看右边
在多态中，静态成员函数的特点，无论编译和运行都参考左边
Object 是所有对象的：根类
Object 类中已经提出对对象是否相同的比较方法
内部类
非静态内部类不能定义静态函数
内部类的访问规则，可以直接访问外部类的成员，包括私有
2外部类要访问内部类，必须建立内部类对象
内部类可以被私有化，外部类觉得不能被私有化
之所以，可以直接访问外部类的成员，是因为内部类有一个外部类的引用
格式 外部类名、this
访问格式，当内部类定义在外部类的成员位置上，而且私有，可以再外部其他类中
可以直接建立 对象，
格式，外部类名，内部类名， 变量名=外部类对象，内部类对象
outer.inner in=new outer.inner();
in.function();
当内部类在成员位置上，就可以被成员修饰符所修饰
Private 将内部类在外部类的进行封装。
当内部类被静态修饰后，只能直接访问外部类中的静态成员，出现了访问局限
在外部其他类，如何直接访问静态内部类呢？
new outer.inner().function();来直接访问内部类的非静态成员
在外部其他类，如何直接访问非静态成员呢？
outer.inner().function();
注意，：当内部类中定义静态成员，该内部类必须是静态的
当外部类中的静态方法访问内部类是内部类也必须是静态的
内部类的作用就是能直接访问外部类的事物
内部类定义局部是，不可以被成员修饰
可以直接访问外部类中的成员，因为还持有外部类中的引用
但是不可一访问他所在的局部中的变量，只能访问被final修饰的局部变量
class Outer {
int x = 9;
void method(final int a) {
final int y=4;
class inner {
void function() {
System.out.println(a+y);
}
}
new inner().function();
}
}
class innerobject {
public static void main(String[] args) {
new Outer().method(5);
new Outer().method(6);
}
}
匿名内部类，就是内部类，的public void run(){
for(int x=0;x<100;x++)
{
System.out.println(Thread.currentThread().getName()+".."+x);
}
}式
2，定义匿名内部类的前提，内部类必须继承一个类，
或者实现一个接口
匿名类 的格式写法 new 父类或者借口(){定义子类内容}
class
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
abstract class Absdemo
{
abstract void show();
}
class outer
{
int x=3;
public void function()
{
//这就是创建匿内部名类
new AbsDemo()
{
void show()
{
System.out.println("x="+x);
}.show();//调用成员方法
}
}
}
5.匿名内部类中定义的方法最好不要超过三个。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
