//
造车：1. 画图纸.
1. 定义车的属性信息: color, speed, seat2.
定义车的动作:跑.
2.拿着图纸找工厂生产车面向对象的世界里类:就是图纸属性:
这一类事物拥有的共同属性动作：这一类事物共同能执行的功能对象:
使用类创建的具体某一个东西I对象能干什么？
完全取决于类是如何定义的写代码类要使用class来定义属性:成员变量来描述.
直接写在类中的变量.动作:
成员方法.不写static就是成员方法创建对象:类 引用 = new 类();
//创建对象
public class Car { //创建类的属性 String color; //颜色 int speed; //速度 int seat; //座位 //int seat1 = 5; //座位 也可以直接赋值 //成员方法 public void run(){ System.out.println("车跑起来"); } public static void main(String[] args) { //程序入口
int a =1 方法里的局部变量 //创建对象 Car c = new Car(); c.color = "红色"; //c.aa =10; 这里调用者 不可以加属性 跟python 不一样 python 创建对象之后 加了属性 相当于 在这个创建对象的内存空间里可以生成这个属性 c.run(); System.out.println(c.color);
Car c2 =new Car();
c2.color = "绿色"
c2.fly(color:"黑色") } }
//this
public void run(){
//this 是调用方法的本身,比如 是c对象调用了该方法 那么就执行c里面的方法
System.out.println(this.color);
System.out.println("车跑起来");
}
public void fly(String color){
// 此时访问的是也是成员变量, 变量的查找顺序;先找自己方法内,如果自己没有 就去this 里去找
//System.out.println(color+"车飞起来");
System.out.println(this.color+"颜色的车会飞,飞在+color+颜色的云彩里")
}
构造方法:
public class Car {
//创建类的属性
String color; //颜色
int speed; //速度
int seat; //座位
//int seat1 = 5; //座位 也可以直接赋值
// java 会自动的赠送给每一个类一个无参数的构造方法
// 如果你自己定义了构造方法, java就不再赠送你了
//在创建对象的时候,自动调用方法
public Car(String color; int speed){
//设置属性信息
this.color = color;
this.speed =speed;
}
//成员方法
public void run(){
System.out.println(this.color+"颜色的车在跑");
}
public static void main(String[] args) {
//程序入口
//创建对象
Car c = new Car(color: "绿色", speed: 120);
//c.color = "红色1";
//c.aa =10;
c.run();
Car c = new Car(color: "红色", speed: 100);
//c.color = "红色1";
//c.aa =10;
c.run();
} }
构造方法重载:
public class Car {
//创建类的属性
String color; //颜色
int speed; //速度
int seat; //座位
//int seat1 = 5; //座位 也可以直接赋值
// java 会自动的赠送给每一个类一个无参数的构造方法
// 如果你自己定义了构造方法, java就不再赠送你了
//在创建对象的时候,自动调用方法 public class daxia(){
String name;
String waihao;
int age;
String bangPai;
} //我们需要构造两个方法 public DaXin(String name, int age, String banPai){ this.name =name;
this.age =age;
this.bangPai =bangPai; }
// 构造方法也是方法 也可以进行重载
//可以让我们有更多的方式去创建对象
public DaXin(String name, int age, String banPai,String waihao){
this(name ,age ,bangPai); //this 还可以调用当前类中的其他的构造方法
this.waihao =waihao;
}
public static void main(String[] args) {
//余不群
DaXin dx1 =new DaXia(name:"岳不群",age: 18, bangPai: "华三派");
DaXin dx2 =new DaXia(name:"武松",age: 182, bangPai: "光明派")
}
}
static 静态方法:
public class Test01 {
String name;
static String country = "大清"; //它是共享的. 存在一个内存中 只要修改了它的值 那么其他方法 使用时 都是共享一个数据的
String address;
public Test01(String name, String address){
this.name = name;
this.address =address;
}
public static void main(String[] args) {
Test01 p1 = new Test01("赵四","八大胡同");
Test01 p2 = new Test01("赵五", "曹阳们");
//大清亡了
p1.country = "民国";
System.out.println(p1.country);
System.out.println(p2.country);
}
}
//使用p1.country = "民国", 不推荐这样使用静态变量
推荐使用类名去访问静态的内容
特点:
1: 数据共享 2: 属于类的,并不属于对象 3,优先于对象产生的
通用构造器,静态构造器
创建对象的过程
1: 静态构造器 2: 通用构造器 3.构造方法 .> 创建对象
由于创建对象的过程是在静态内容加载完成之后,在静态方法喝静态块里 不能使用this
包和导包:
包 ,其实本质上就是文件夹
在代码中需要些package 包名;
导包:
import 包+类 快捷键Alt+Enter
不需要导包:
1: 在自己包里 比如同一个文件夹下
2: java.lang 包下的所有内容都不需要导包
String
system.out println()
访问权限:
1: public 公共的 所有人可以访问
2: default 包访问权限 在自己包内可以随意访问.
3: private 私有的 只有 自己类里面 可以访问
getter 和 setter
成员变量一般试用private来声明,保护成员变量不被胡乱的赋值
所以 :
setter : 主要是给成员变量赋值 做一定的保护 比如 规定的是age 没有-1 可以在setter 里面进行个判断 然后 给到 类里面的 变量 this.age = age
getter : 从成员变量中获取数据
每次写太麻烦 快捷方式 空白位置.>右键>genrate>getter and setter > 全选 > ok
继承
继承: 子类可以自动拥有父类中除了私有内容外的其他所有内容.
当出现x 是一种 y 的时候 x 就可以继承y
黑熊怪是一种妖怪.
public class 类 extends 父类{
// 这里可以直接调用父类的方法跟属性 //私有的除外
}
备注: 简化代码的开发 子类对父类进行了扩展
super()
1 :当子类继承父类之后 可以通过super.xxx 直接调用父类里面得属性
2: 子类调用父类的时候 可以给super(传参),这里注意 java 默认是 当子类创建了对象 时 会先执行构造方法,然后 会先执行父类 也就是super 所以如果想给父类super传参的话 需要写在子类构造方法的最上面一行
方法的重写
重写 子类对父类中提供的方法进行重新定义
语法 子类和父类中的方法的声明完成一致 比如 写的方法 都一样
重写 又被称为方法的覆盖 就是 先找子类自己的定义方法 如果也想执行父类的方法 直接super().方法名即可
多态
多态 同一个对象拥有多种形态
作用 把不同的数据类型进行统一 让程序具有超强的可扩展性 比如 猫 狗 统一为动物
小知识点:
1: 把子类的对象赋值给父类的变量 > 向上转型
缺点 屏蔽掉子类中特有的方法
2: 把父类的变量转化回子类的变量 >向下转型
向下转型有可能有风险 java要求 必须写强制类型转换
(转换之后的数据类型)变量 其实 就是比如 Cat c = (Cat)变量
final
final 定义的变量 一般为不可变变量 也相当于常量
1:被final 修饰的变量 不可改变 被final 修饰的方法 不可被重写 被final修饰的类 不可继承
抽象:
现实中不存在的东西
在java中:只声明.不实现
抽象方法,使用abstract 来修饰,不可以有方法体,直接用分号结束即可! 不用后面来个{}
抽象类:如果一个类中有抽象方法,这个类必须是一个抽象类
特点:
1:抽象类不可以创建对象
2: 抽象类的子类 必须重写父类中的抽象方法 否则 子类必须也是抽象类
通过抽象类可以强制的要求子类中必须有哪些方法
小知识点:抽象类中可以有正常的方法
接口
接口 特殊的抽象类
其实 接口 相当与 比如 你写个接口 里面定义了一些功能 然后交给抽象类,那么抽象类可以实现部分的功能,然后剩下的功能 可以让子类去完成 ....
成员变量的初始值
成员变量 默认是要先定义再复值得 ,比如 int age =10; 但是 如果创建对象,比如
在另一个类中 定义 int age; 那么这时打印 会有默认值 一般都是0 与null
Object
其实类上面 都会默认继承Object类 也就是基类 ,然后object 里面封装了一些可以直接使用的功能
1: equals 和 ==
== 判断左右两端的数据是否一致==
equals:object 类提供的一个方法,用来判断两个对象是否相等
equals 可以自己重写 比如 写个类 类里写个equals 那么此时调用equals 是调用自己写的
== 判断两个值的内存地址 是否一致
如果使用字符串进行判断 需要使用 equlas 这里是根据值的内容 去做比较的
2:toString
toString() 对一个对象的字符串的表示形式
java 官方推荐你重写这个方法,默认的那个太丑了
其实toString 就是比如 你返回的是个内存地址对象 但是想返回对象的值,可以return toString 相当于 python Django 里面的return __str__ 方法
instnceod关键字
判断 xxx对象是否时xxx类型的
内存分析
异常处理
1:
-try .. catch
try{
尝试执行的代码
}catch(Exception e){
处理异常的代码
}finally{
最终的. //一般是收尾工作
}
2: throws 和 throw
throws 告诉外面,我要扔一个异常,所以调用者要捕捉该异常,
throw 真正的向抛出一个异常,就是自己的程序 如果觉得有异常 还是自己处理比较好
3: 自定义异常
直接继承Exception或者RuntimeException来实现自定义异常
标签：java,String,color,子类,面向对象,int,父类,public From： https://www.cnblogs.com/ZhiXiaoBbai/p/17030454.html