面向对象
面向过程:过程就是功能、动作,就是说面对的主要是大量无序排列的功能(basic和C语言,VB是一个工具)
面向对象:其实就是对各种功能进行了打包分类,我们会先面对的是对象,再对其内的功能、动作进行调用
作用意义:面向对象是一种思想,能让复杂的事情简单化,能让我们从执行者转变为指挥者
匿名对象:当对对象的方法只调用一次时,使用匿名对象较方便;匿名对象作为实际参数进行传递时较为方便
1.封装(Encapsulation)
1.1 封装要点
(1)封装的意义:隐藏对象的属性和实现细节,对外提供公共访问方式,封装的出现才让的权限可以定义
(2)优点:<1>.隔离变化 <2>.便于使用 <3>.提高安全性
(3)Java从小到大的封装体:函数-->类-->包-->框架
1.2 构造函数
(1)规定: <1>.函数名与类名相同 <2>.不用定义返回值类型 <3>.不可以写return语句
(2)作用:给对象进行初始化,没有构造函数对象无法建立
(3)特点:<1>.对象一建立就执行 <2>.只执行一次
(4)注意:自定义构造函数后,系统不会默认添加空参数的构造函数
(5)构造代码块:对所有对象进行统一初始化,构造函数中共性内容定义在这里面
class Person
{
{
//构造代码块
}
Person(){
//空参构造函数,当没有添加构造函数时系统会默认添加这个
}
Person(String name){
//有参数的构造函数,定以后系统不会默认添加空参的构造函数
}
}
1.3 this关键字
(1)this表示本类对象,是所在函数所属对象的引用
(2)this语句:this(参数),构造函数间相互调用只能通过this语句,并且该语句只能定义在构造函数第一行
class Person
{
private String name;
Person(){
this("java");//this语句
}
Person(String name){
this.name = name;//this的用法1
}
}
1.4 static(静态)关键字
(1)只能修饰成员,修饰内容被对象所共享,并且可直接被类名调用,写法为类名.静态成员
(2)静态变量(类变量):随着类的加载而存放在方法区中,生命周期最长,被每个对象所共享,共性内容定义为静态变量较好
(3)静态函数:方法只要没用到非静态成员即可定义为静态
(4)特殊:当一个类中全部方法都是静态的时,应该私有化构造函数,禁止该类创建对象,这就是一个工具类
(5)方法区:存放共性内容,因为每个函数只是调用的数据不同,方法体是共性的,存在于这里
class Person
{
String name;
static String country = "CN";//静态变量(类变量)对象共享数据
public String getName(){
return "方法"+name+country; //普通方法可以引用静态成员
}
public static String getCountry(){//静态方法不能引用非静态成员
return "静态"+country;
}
}
class java
{
public static void main(String[] args){
Person p = new Person();
System.out.println("成员变量:"+p.name);
System.out.println("静态成员变量:"+Person.country);//可用直接用类名调用
System.out.println("========================================");
System.out.println("普通函数:"+p.getName());
System.out.println("静态函数:"+Person.getCountry());//可用直接用类名调用
}
}
(6)main函数中args是一个字符串类型的数组,JVM运行主函数时是往其传入了一个new String[0]的数组
(7)静态代码块:随着类的加载而执行,给类进行初始化,并且只执行一次
(8)对象的创建到消亡的全部过程(Person p = new Person();)
<1>.编译java文档,把class文件加载进内存 |
<2>.方法和静态成员存放在方法区中 |
<3>.静态代码块初始化(如果有的话) |
<4>.在堆内存开辟空间,分配地址值
|
<5>.在堆内存中建立对象,并且对其属性进行默认初始化
|
<6>.对属性进行显示初始化
|
<7>.构造代码块初始化
|
<8>.特定构造函数初始化
|
<9>.内存地址值分配给类类型变量
|
<10>.对象被垃圾回收掉
|
<11>.方法和静态成员从方法区中随着类的消亡而消亡 |
2.继承(Extend)
2.1 继承的要点
(1)优点:<1>.提高了代码的复用性 <2>.使类与类之间产生了关系,才有了多态的特性
(2)弊端:打破了类的封装性
(3)内存:创立的子类对象在堆内存中会有两块区域,一块为子类属性,一块为父类属性
(4)复写(重写、覆盖)注意:<1>.复写方法时,适当的使用【super.父类函数名(参数)】的方式简化代码 <2>.静态方法只能被静态方法所覆盖
(5)每一个子类的构造函数中第一行都有一行隐式的super();语句,调用父类空参构造函数。
<1>.父类必须有空参数的构造函数
<2>.如果真没有,子类构造函数第一行需手动指定要访问父类哪一个构造函数,如super(3);
class father
{
father(){}//父类必须要有空参构造函数
father(int x){
System.out.println("father......."+x);
}
public static void study(){}
}
class son extends father
{
son(){
super();//系统默认会添加这一句代码
System.out.println("son");
}
son(int x){
super(x);//手动指定要访问的构造函数
System.out.println("son........"+x);
}
public static void study(){}//只有静态方法能够覆盖静态方法
}
2.2 final关键字
(1)final修饰的变量是常量,只能赋值一次(可以修饰局部变量)
(2)final修饰的方法不能被覆盖
(3)final修饰的类不能被继承
(4)局部内部类只能访问该局部被final修饰的局部变量
final class java //final修饰的类是终类,不能被继承
{
final double PI=3.14;//PI是一个常数
final void test(){//方法不能被复写
System.out.println("final方法");
}
}
2.3 抽象类(abstract)
(1)抽象类无法创建对象,因为调用抽象方法没意义
(2)继承抽象类,子类必须复写父类所有抽象方法,不然子类也是抽象类
2.4 接口(interface、implements)
(1)成员固定修饰符(默认系统添加,建议自己书写,方便阅读)
变量:public static final(全局常量)
方法:public abstract
(2)注意:<1>.一个类继承一个类的同时能实现多个接口 <2>.接口与接口之间支持多继承
(3)特点:<1>.对外暴露的规则 <2>.提高了功能的扩展性 <3>.降低了耦合性 (依赖性,可以各做各的,不影响结果)
(4)如何定义接口:一般都应该具有的功能通过继承传递;可能具有的功能定义为接口,并且可定义多个接口,通过实现来传递
(5)Java中的接口其实和现实中物理接口含义差不多,可通过以下代码来说明
/**
*需求:定义一个主板、显卡、声卡、网卡仿真关系来说明接口的意义(现实与Java的关系)
*设计:1.定义主板类,并且具有run()、cardRun()方法
* 2.只要显卡,声卡,网卡都接上电运行后主板即可运行
*
*/
interface PCI//物理主板上的PCI接口的规格
{
void open();
void close();
}
class MainBoard
{
public void run(){
System.out.println("主板开始启动,启动正常");
}
public void cardRun(PCI p){//表示主板上有PCI接口的插槽
if(p!=null){
p.open();
p.close();
}
}
}
class VedioCard implements PCI //表示显卡按照PCI接口规格设计
{
public void open(){};
public void close(){};
}
class SoundCard implements PCI //表示声卡按照PCI接口规格设计
{
public void open(){};
public void close(){};
}
class NetCard implements PCI //表示网卡按照PCI接口规格设计
{
public void open(){};
public void close(){};
}
class java
{
public static void main(String[] args){
MainBoard mb = new MainBoard();
mb.cardRun(new VedioCard()); //把显卡插在主板上
mb.cardRun(new SoundCard()); //把声卡插在主板上
mb.cardRun(new NetCard()); //把网卡插在主板上
mb.run();//主板运行
}
}
3.多态(Polymorphism)
3.1 多态要点
(1)意义:父类引用指向子类对象,主要是为了解决函数参数列表的单指向性
(2)前提:父类引用只能调用子类继承或实现的方法,不能调用子类独有方法
(3)特点:<1>.提高代码扩展性
(4)注意:<1>.不要把父类对象转成子类类型 <2>.调用子类对象特有方法时代码实现方式如下
/**
*需求:如何使用父类引用调用子类特有方法
*/
abstract class Animal
{
abstract void eat();
}
class Cat extends Animal
{
public void eat(){
System.out.println("吃鱼");
}
public void catchMouse(){
System.out.println("捉老鼠");
}
}
class java
{
public static void main(String[] args){
Animal a = new Cat(); //类型提升,向上转型
Cat c = (Cat)a; //向下转型,想使用子类独有方法需要这样转型后使用
get(a);
}
public static void get(Animal a){
a.eat();
if(a instanceof Cat){
Cat c = (Cat)a;//强制转换
c.catchMouse();
}
}
}
<3>.定义重载函数,如果函数之间有多态的关系,那么超类类型的参数必须定义在最下边,不然编译失败
(5)面试:多态使用时调用父类引用调用成员变量或者静态方法,全部指向的是父类。因为方法或者变量都已经绑定,静态优先于对象存在
3.2 instanceof关键字
(1)公式:待判断变量 instanceof 目标类型
(2)返回值:true 或 false
3.3 Object类(上帝类、根类、超类)
boolean | equals(Object obj) 指示其他某个对象是否与此对象“相等”。 |
Class<?> | getClass() 返回此 Object 的运行时类。 |
int | hashCode() 返回该对象的哈希码值。 |
String | toString() 返回该对象的字符串表示。 |
3.4 内部类(内置类、嵌套类)
(1)成员位置
<1>.意义:内部类就是在外部类中的一个事物。例如人与心脏。
<2>.访问方式:外部类名.内部类名 引用名 = new 外部类名().new 内部类名()
<3>.特点:a.内部类能访问外部类成员,包括私有。因为引用前都有隐式的 外部类名.this
b.内部类能被成员修饰符所修饰public、private、static、final、abstract
c.静态内部类特点与静态方法类似
访问静态内部类的非静态方法 new 外部类名().内部类名().方法名()
访问静态内部类的静态方法 外部类名.内部类名.方法名()
d.内部类通常被private修饰,因为内部类一般不对外暴露
(2)局部位置
<1>.注意:a.不能被成员修饰符所修饰 b.访问局部变量时,此变量必须被final所修饰
(3)匿名内部类
<1>.意义:匿名内部类实质上是一个匿名的子类对象
<2>.规则:此内部类必须实现或继承一个接口或类
<3>.格式:new 父类名(参数){类中的内容}
<4>.特点:不定义父类,可以用Object代替
//匿名内部类的实现
interface Inter
{
void method();
}
class Test
{
//补足代码,通过匿名内部类
public static Inter function(){
return new Inter(){//返回的是一个静态内部类
public void method(){
System.out.println("匿名内部类");
}
};
}
}
class java
{
public static void main(String[] args){
Test.function().method();
}
}
3.5 包(package)
(1)包就是对类文件进行分类管理的文件夹,给类提供了多层命名空间
(2)编译方式:javac -d . java文件名.java
运行方式:java 包名.class文件名
(3)当出现包后需要注意的事项
<1>.创建对象,用到类的地方都要用 包名.类名 命名
<2>.创建的对象类中方法与类都要用public修饰符修饰
(4)关键字protected:只能该类的子类能够访问被此关键字修饰的方法
(5)权限修饰符的访问局限表
public | protected | default | private | |
---|---|---|---|---|
同一个类中 | 能 | 能 | 能 | 能 |
同一个包中 | 能 | 能 | 能 | |
不同包子类 | 能 | 能 | ||
不同包 | 能 |
(6)关键字import:简化包名书写的关键字,一般采用url地址值为包名。注意导入的是类,不能导入包
(7)jar包
<1>.当有多个包(文件夹)存在,携带不方便,可以打成一个jar类型的压缩包
<2>.dos命令行格式:jar -cf jar文件名.jar 包名,包名.....
<3>.web编程中的导包就是在classpath里指向jar包
<4>.JDK本地目录\jre\lib\rt.jar包中存储的是java的类库,java常用的对象都在此文件里面
<5>.JDK本地目录\lib\tools.jar包内有javac.exe主程序Main.class类
4.知识点
(1)native关键字表示调用本地系统的方法,本此关键字修饰的方法看不见方法体,不允许用户查看
(2)JDK本地目录\src.zip中是Java全部的源文件
(3)Java5块内存空间——栈内寸、堆内存、方法区、寄存器、本地方法区(native关键字)