1、面向对象
面向对象是基于面向过程的编程思想。
面向对象的思想特点：
- 是一种更符合我们思考习惯的思想
- 把复杂的事情简单化
- 让我们从执行者变成了指挥者
Java程序的开发，设计和特征
- 开发：就是不断的创建对象，通过对象调用功能
- 设计：就是管理和维护对象间的关系
- 特征：封装，继承，多态
2、类定义
Java语言中最基本的单位是类。所以，我们要用类来体现事物，事物由属性（事物的描述）、行为（事物功能）组成
类：是一组相关的属性和行为的集合
类是一个不存在的，虚拟的，对象是是实实在在存在的
如何定义类
[修饰符] class 类名{
}
成员变量（事物属性）：在类中，方法外
成员方法（事物行为）
对象：是该类事物的具体存在，是一个具体的实例。比如 学生：类 ；班长：具体对象
创建对象并使用格式：
类名 对象名 = new 类名();
public class Phone {
String brand;
int price;
String color;
//打电话的方法
public void call(String name) {
System.out.println("给"+name+"打电话");
}
}
public class PhoneDemo {
public static void main(String[] args) {
//创建手机对象
//类名 对象名 = new 类名();
Phone p=new Phone();
p.call("张三"); //给张三打电话
p.brand="huawei";
p.price=3000;
p.color="白色";
System.out.println(p.brand+"---"+p.price+"---"+p.color);//huawei---3000---白色
}
}
3、成员变量和局部变量
区别:
- 作用域 局部变量只能在类的方法中定义
- 成员变量可以没有初始值,局部变量必须有
- 变量同名,局部变量优先级更高
A:在类中的位置不同
成员变量：在类中，方法外
局部变量：在方法定义中或者方法声明上
B:在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
C:生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
注意事项：
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
为了解决这一问题，引用了this关键字
this关键字：
代表当前类的引用对象
哪个对象调用方法，该方法内部的this就代表那个对象
解决了局部变量隐藏成员变量的问题
定义一个类
public static class Var{
int num=10;
public void show(int num){
System.out.println(num);
System.out.println(this.num);
this.num=num;
System.out.println(num);
}
}
main方法中：
Var v = new Var();
System.out.println(v.num); //10，调用对象成员变量
v.show(20);
输出结果：
System.out.println(num); //20,就近原则，取局部变量值
System.out.println(this.num); //10，this指明调用的是成员变量
System.out.println(num); //20，this.num=num;局部变量的值重新赋值给了成员变量
3.1static 成员变量
变量 静态成员变量 是类所有的，不是某一个对象所有的
方法 普通方法可以调用静态方法，反过来是不行的
代码块 比构造方法还要早，在类加载的时候执行,而且执行一次，就是在类加载的时候
4、形参和匿名
如果你看到一个方法需要的参数是一个类名，就应该知道这里实际需要的是一个具体的对象。
class Student{
public void show(){
System.out.println("我爱学习");
}
}
class StudentDemo{
public void method(Student s){ //形参是类名，其实是需要的一个具体对象
s.show();
}
}
public class NoNameDemo {
public static void main(String[] args) {
Student s=new Student();
StudentDemo sd=new StudentDemo();
sd.method(s);
sd.method(new Student());
//匿名对象调用
new StudentDemo().method(new Student());
}
}
注意:
匿名对象调用：没有名字的对象；仅仅只调用一次的时候；可以作为实际参数传递
5、构造
作用：用于对对象的数据进行初始化
格式：
A:方法名和类名相同
B:没有返回值类型，连void都不能有
C:没有返回值
D.可以有多个构造方法,重载
注意事项：
如果我们没写构造方法，系统将提供一个默认的无参构造方法
如果我们给出了构造方法，系统将不再提供默认构造方法，这个时候，我们要使用无参构造方法，就必须自己给出。
推荐：永远手动自己给出无参构造方法。
标准案例，get，set
public class Student {
private String name;
private int age;
public Student(){ //无参构造
super();
}
public Student(String name,int age){ //带参构造
super();
this.name=name;
this.age=age;
}
public String getName(){
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString(){
return "Student [name=" + name + ", age=" + age + "]";
}
}
public class StudentDemo {
public static void main(String[] args) {
Student s=new Student("feifei",23); //初始化时，使用带参构造方法
String s1=s.toString();
System.out.println(s1);
System.out.println(s.getName()+"--"+s.getAge());
}
}
6、关键字
this关键字
当前对象,谁调用,this(对象)就是谁.
main关键字
main方法的格式讲解：
public static void main(String[] args) {}
public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。
static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。
void:方法的返回值是返回给调用者
main:是一个常见的方法入口。
String[] args:这是一个字符串数组。默认参数
这个东西早期是为了接收键盘录入的数据的。
格式是：java MainDemo hello world java
static特点：
静态的，不需要创建对象，通过类名就可以。就是说不需要new，直接调用类中的方法。
随着类的加载而加载,优先于对象存在
静态方法只能访问静态的成员变量和静态的成员方法
如：
class Teacher{
public int num=10;
public static int num2=20;
public void show(){
System.out.println(num);
}
public static void method(){
System.out.println(num2);//无法访问num，静态只能被静态调用
}
}
public class MainDemo {
public static void main(String[] args) {
//创建对象
Teacher t = new Teacher();
t.show();
System.out.println("------------");
Teacher.method(); //这里是直接调用类中的方法，没有new对象
}
}
final关键字
final可以修饰类，方法，变量
特点：
final可以修饰类，该类不能被继承。
final可以修饰方法，该方法不能被重写。(覆盖，复写)
final可以修饰变量，该变量不能被重新赋值,值无法再改变。因为这个变量其实常量。
常量：
A:字面值常量
"hello",10,true
B:自定义常量
final int x = 10;
super关键字
7、封装
把不想让外界知道的实现细节给隐藏起来，提供公共的访问方式
提高代码的安全性
提高代码的复用性
使用private关键字修饰
private关键字：
私有的意义，可以修饰成员变量和成员方法
被private修饰的后的成员只能在本类中被访问
class Demo{
private int num=10;
public void show(){
System.out.println(num);
}
}
public class PrivateDemo {
public static void main(String[] args) {
Demo d=new Demo();
d.show();
//System.out.println(d.num); //这里就无法调用成员变量num
}
}
8、继承
继承概述：
把多个类中相同的内容给提取出来定义到一个类中。
Java提供了关键字：extends
格式：class 子类名 extends 父类名 {}
好处：
A:提高了代码的复用性
B:提高了代码的维护性
C:让类与类之间产生了关系，是多态的前提
类与类产生了关系，其实也是继承的一个弊端：
类的耦合性增强了。
开发的原则：低耦合，高内聚。
耦合：类与类的关系
内聚：就是自己完成某件事情的能力
Java中继承的特点：
A:Java只支持单继承，不支持多继承。
有些语言是支持多继承，格式：extends 类1,类2,...
B:Java支持多层继承(继承体系)
继承的注意事项：
A:子类只能继承父类所有非私有的成员(成员方法和成员变量)
B:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。
继承中成员变量的关系:
A:子类中的成员变量和父类中的成员变量名称不一样，这个没啥好说的。
B:子类中的成员变量和父类中的成员变量名称一样
在子类方法中访问一个变量的查找顺序：
a:在子类方法的局部范围找，有就使用
b:在子类的成员范围找，有就使用
c:在父类的成员范围找，有就使用
d:如果还找不到，就报错。
this和super的区别:
this代表本类对应的引用。
super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员)
A:调用成员变量
this.成员变量 调用本类的成员变量
super.成员变量 调用父类的成员变量
B:调用构造方法
this(...) 调用本类的构造方法
super(...) 调用父类的构造方法
C:调用成员方法
this.成员方法 调用本类的成员方法
super.成员方法 调用父类的成员方法
继承中构造方法的关系:
子类中所有的构造方法默认都会访问父类中空参数的构造方法
子类初始化之前，一定要先完成父类数据的初始化。
子类每一个构造方法的第一条语句默认都是：super();
方法重写Override：子类中出现了和父类中方法声明一模一样的方法。
方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
这样，即沿袭了父类的功能，又定义了子类特有的内容。
注意：子类重写父类方法时，访问权限不能更低
父类静态方法，子类也必须通过静态方法进行重写
方法重载Overload：（前面的知识）
在同一个类中，方法名相同，参数列表不同。与返回值无关，可以改变返回值的类型
//多层继承
class GrandFather {
public void show() {
System.out.println("我是爷爷");
}
}
class Father extends GrandFather {
private int num=10;
private void showf(){
System.out.println(num);
}
public void method(){
System.out.println("我是老子");
showf();
}
}
class Son extends Father {
public int num2=30;
public Son(){
super();
System.out.println("Son无参构造");
}
public Son(String name){
super();
System.out.println("Son的带参构造"+name);
}
public void function(){
int num2=40;
//System.out.println(num); //子类不能继承父类的私有成员变量
System.out.println(num2);//40,优先使用局部变量
System.out.println(this.num2);//20,this调用本类成员变量
System.out.println(super.num2);//10,super调用父类成员变量
}
public void method(){
super.method(); //father的方法
System.out.println("son特有功能");
}
}
public class ExtendsDemo {
public static void main(String[] args) {
Son son=new Son();
new Son("name");//匿名带参构造
son.method();
son.show();
son.function();
}
}
9、多态
多态：同一个对象(事物)，在不同时刻体现出来的不同状态。例如：水(液体，固体，气态)。
多态就是父类使用子类的重写方法，如要使用父类本身的方法，就必须要新建一个父类对象；如果要使用子类特有的成员变量和方法，就必须向下转型。
多态的前提：
A:要有继承关系。
B:要有方法重写。
动物 d = new 猫();
d.show();
动物 d = new 狗();
d.show();
C:要有父类引用指向子类对象。
父 f = new 子();
多态中的成员访问特点：
A:成员变量
编译看左边，运行看左边。
B:构造方法
创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
C:成员方法
编译看左边，运行看右边
D:静态方法
编译看左边，运行看左边。
(静态和类相关，算不上重写，可以直接通过类名访问成员方法，所以，访问还是左边的)
由于成员方法存在方法重写，所以它运行看右边。
对象间的转型问题：(从右往左念)
向上转型：（子类的对象赋值给父类）
Fu f = new Zi();
向下转型：（父类强制转换成子类并且把对象赋值给子类）
Fu f = new Zi();
Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。
class Fu {
public int num = 100;
public void show() {
System.out.println("show Fu");
}
public static void function() {
System.out.println("function Fu");
}
}
class Zi extends Fu {
public int num = 1000;
public int num2 = 200;
public void showfu(){
super.show();
}
public void show() {
System.out.println("show Zi");
}
public void method() {
System.out.println("method zi");
}
public static void function() {
System.out.println("function Zi");
}
}
public class DuoTaiDemo {
public static void main(String[] args) {
//要有父类引用指向子类对象。
Fu f = new Zi();
System.out.println(f.num);//100，访问成员变量，看左边，左边是父；编译看左边，运行看左边
//子类重写了父类的show方法，相当于有多种形态，符合多态特征
f.show(); //访问成员方法，编译看左边，运行看右边，所以这里的结果是子的show（）
f.function();//静态方法 编译和运行看左边
//多态弊端：不能访问子类特有得成员变量和成员方法
//找不到符号
//System.out.println(f.num2);
//找不到符号
//f.method();
Zi z=(Zi)f;//所以只能向下转型，才能使用子类的特有成员
System.out.println(z.num2);
z.method();
//子要使用父类被重写的方法，可以在子类super父类被重写的方法
z.showfu();
}
}
10、抽象类
抽象类的概述：
动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的。
我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。
抽象类的特点：
A:抽象类和抽象方法必须用abstract关键字修饰
B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类
C:抽象类不能实例化，因为它不是具体的。
抽象类有构造方法，但是不能实例化，用于子类访问父类数据的初始化
D:抽象的子类
a:如果不想重写抽象方法，该子类是一个抽象类。
b:重写所有的抽象方法，这个时候子类是一个具体的类。
抽象类的实例化其实是靠具体的子类实现的。是多态的方式。
Animal a = new Cat();
abstract class Animal{
public abstract void eat(); //抽象类不能被实力化，没有方法体
public Animal(){
//抽象类中不一定都是抽象类
}
public void method(){
System.out.println("method");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
}
public class AbstractDemo {
public static void main(String[] args) {
Animal a=new Cat();
a.eat();
a.method();
}
}
11、接口
他定义了一批类必须遵循的规范.他也不关心实现细节
[修饰符] interface 接口名 [extends 父接口1,父接口2]
{
[常量定义]
[方法定义]
}
接口的特点：
A:接口用关键字interface表示
interface 接口名 {}
B:类实现接口用implements表示
class 类名 implements 接口名 {}
C:接口不能实例化
按照多态的方式来实例化。
D:接口的子类
a:可以是抽象类。但是意义不大。
b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
强制具体类实现接口所有方法，子类方法可以是继承关系，父子类分担接口中的方法
由此可见：
A:具体类多态(几乎没有)
B:抽象类多态(常用)
C:接口多态(最常用)
接口成员特点
成员变量；只能是常量，并且是静态的。
默认修饰符：public static final
建议：自己手动给出。
构造方法：接口没有构造方法。
成员方法：只能是抽象方法。
默认修饰符：public abstract
建议：自己手动给出。
所有的类都默认继承自一个类：Object。
类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
类与类：
继承关系,只能单继承,可以多层继承。
类与接口：
实现关系,可以单实现,也可以多实现。
并且还可以在继承一个类的同时实现多个接口。
接口与接口：
继承关系,可以单继承,也可以多继承。
抽象类和接口的区别：
A:成员区别
抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象
B:关系区别
类与类
继承，单继承
类与接口
实现，单实现，多实现
接口与接口
继承，单继承，多继承
C:设计理念区别
抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。
interface AnimalTrain{
//成员变量只能是常量，且默认是静态的
int num=10;
//省略的部分
public static final int num1=20;
//成员方法只能是抽象方法
public void jump(); //默认修饰符public abstract
public abstract void sleep();
public abstract void eat();
}
class Animal{
public void eat() {
System.out.println("eat");
}
public void sleep() {
System.out.println("sleep");
}
}
class Cat extends Animal implements AnimalTrain{
public void jump(){//重写接口中的方法
System.out.println("猫可以跳高");
}
}
public class InterfaceDemo {
public static void main(String[] args) {
Cat c=new Cat();
c.jump(); //调用的是接口被重写的方法
c.sleep(); //继承Animal的方法
c.eat(); //继承Animal的方法
//多态实现,强制具体类实现接口所有方法，子类方法可以是继承关系，父和子类可以分担，重写接口中的方法
AnimalTrain at =new Cat();
at.jump();
at.sleep();
at.eat();
}
}
12、包
其实就是文件夹
不同文件下是可以创建相同的类名的 a/b/c/d a.b.c.d 规范:公司网站 倒过来写
区分同名的类
对类进行分类管理
包的定义：package 包名; 多级包用.分开
导包：import 包名…类名;
13、权限修饰符
权限修饰符
本类 同包不同类 同包子类 不同包下类 不同包下子类
private Y
默认 Y Y Y
protected Y Y Y Y
public Y Y Y Y Y
分类：
权限修饰符：private,默认,protected,public
状态修饰符：static,final
抽象修饰符：abstract
常见的类及其组成的修饰
类：
默认,public,final,abstract
常用的：public
成员变量：
private,默认,protected,public,static,final
常用的：private
构造方法：
private,默认,protected,public
常用的：public
成员方法：
private,默认,protected,public,static,final,abstract
常用的：public
扫一扫
164
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
