JAVA面向对象
类和对象
类：具有相同属性（特征）和行为(动作)对象的集合。抽象出来的
对象：类的实例化
常见修饰符
static(静态) final(最终方法) abstract(抽象) native(调用C函数库) synchronized(同步锁)
类修饰符
Public : 同包和不同包内都能访问
Protected : 在同类和同包,子父类里可以访问
Defailt : 在同类同包访问
Private : 只能同类访问
静态块、构造块、局部块
静态块：在类被加载时被调用，一般用来初始化类，为类属性初始化
构造块：在类的构造方法被调用时，先于构造方法执行，初始化对象数据
局部块：在方法中减少部分变量生命周期，释放内存空间
静态变量和局部变量
静态变量：从属于类，在类加载时被分配空间直接类名调用
实例变量：从属于对象，在对象被创建时分配空间，通过对象实例调用
对象在内存中存储结构
public class TestStudent {
public static void main(String[] args) {
int n = 10; //栈存储
int m = 10; //栈存储
Student stu = new Student();
//属性赋值
stu.name="张三";
System.out.println(stu.name); //null 张三
System.out.println(stu.age); //0
//调用
String name = "ls"; //局部变量(常量池)
String aaaa="ls";
String pwd = "123";
stu.login(name,pwd);
System.out.println("name:"+name); //ls
System.out.println("执行");
}
}
class Student {
// 属性
String name;
int age;
//用户登录
// String userName;
// String pwd;
public void login(String userName,String pwd){
System.out.println(userName+"===="+pwd); //ls 123
}
public void show() {
System.out.println("姓名：" + name + ",年龄：" + age);
}
}
方法重载(两必一可)
特点：
①方法必须在同一类中且方法名相同;
②方法名必须相同;
③参数列表必须不一致
(a.参数类型b.参数个数c.参数的顺序)
补充：与方法的返回值类型无关(可以相同也可以不同)
值类型和引用类型作方法的参数区别
public class Test1 {
public static void main(String[] args) {
int num =10;
System.out.println(num); //10
new Test().show(num); //
System.out.println(num); //10
System.out.println("---------------------");
Test2 test2 = new Test2();
test2.i =10; //n=0
System.out.println(test2.i); //10
new Test().show(test2); //i=10 n= 0
System.out.println(test2.i); //11
}
}
class Test{
public void show(int i) {
i++;
}
public void show(Test2 t) {
t.i++;
}
}
class Test2{
int i;
}
public class TestSwap {
public static void main(String[] args) {
// int n=10,m=8;
// System.out.println("n:"+n+",m:"+m); //10 8
//
// swap(n,m); //值类型作为方法的参数
// System.out.println("n:"+n+",m:"+m); //10 8
DataSwap ds = new DataSwap();
ds.n=10;
ds.m=8;
System.out.println("n:"+ds.n+",m:"+ds.m); //10 8
swap(ds); //引用类型作为方法的参数
System.out.println("n:"+ds.n+",m:"+ds.m); //8 10
}
//交换(值类型 基本数据类型)
public static void swap(int n,int m) {
int tmp = n;
n = m;
m = tmp;
// System.out.println("n:"+n+",m:"+m); // 8 10
}
//交换(引用类型)
public static void swap(DataSwap ds) {
int tmp = ds.n;
ds.n=ds.m;
ds.m = tmp;
}
}
class DataSwap{
int n;
int m;
}
this关键字
作用：this关键字代表当前的对象或正在创建的对象
this关键字修饰什么：
1）属性 this.属性
2）方法 this.方法();
3）构造器 this(参数)
在构造器this注意事项：①this必须放在构造方法的第一行 ② 有n个构造方法 this 只能出现n-1
tis: this调用参数时，优先寻找子类对象，没找到后寻找父类对象。
javaBean和相关的关键字(package、import)
javaBean标准：①该类的公共的(public) ②私有的属性并且提供getter/setter方法
package: 作用：
定义包；以目录方式管理javaBean
写在类的首行,目录结构以“.”分隔;如 package 包名;
定义包的规范：项目类型.公司名称.项目名称.模块名称;包名所有字母小写的
import:作用：导入相关类
方式：import 包名.类名/接口名;
特点：可以使用“*”代表包下的所有类或接口.
如果调用不同包中的相同的类名，创建对象时要定义类的全路径;
如：包名.类名 对象=new包名.类名();
java.lang包下接口或类自动导入不需要import ;如： String ,System,Math等 ，
补充：静态导入 import static 包名.类.静态成员;
继承
为什么要用继承?目的实现代码的复用
语法：class subclass extends superclass 子类（派生类） extends 父类(基类或超类)
特点：
1)子类继承父，拥有(继承)父类中的所有成员,在权限范围内.
2)子类不能继承父类中的构造器，只能用super调用.
3)类的继承关系统是单继承,子类只能有一个直接父类；父类可以有多个子类
4)继承具有传递性,如果没直接继承父类，默认继承java.lang.Object类
5)extends 扩展,子类不是父类的子集是父类的扩展。
方法重写(override/overwrite)
什么是重写:对父类方法覆盖（覆写）
重载(overload):必须在同一个类，方法名相同，参数列表不同，与返回值类型无关
前提:
1)一定有继承关系
2)子类方法和父类方法的返回值类型，方法名称，参数方法列必须一致.
3)子类方法的权限修饰符不能小于父类的权限修饰符
4)子类方法抛出异常不能大于父类方法抛出的异常
5)子类方法和父类方法同为static或非static.
多态
多态:一个事物的多种表现形态。(两个或两个以上的对象在调父类中的方法时，实现了各自的内容)
多态代码：父类 对象 = new 子类(); 父类引用指向子类对象
子类 对象 = new 父类() ; //不可以
多于多态来说，编译状态(看左边的类型) ，运行状态(看右边的类型)
实现：向上转型 : 父类 对象 = new 子类(); 理解:自动类型转换
向下转型 : 父类类型对象 instanceof 子类类型 => 子类类型 对象=(子类类型)父类类型的对象 ;
类的属性没有多态性(属性不能被子类的属性覆盖)
public class Test {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println(a1.show(b)); // "A and A"
System.out.println(a1.show(c)); // "A and A"
System.out.println(a1.show(d)); // "A and D"
System.out.println(a2.show(b)); // "B and A"
System.out.println(a2.show(c)); // "B and A"
System.out.println(a2.show(d)); // "A and D"
System.out.println(b.show(b)); // "B and B"
System.out.println(b.show(c)); // "B and B"
System.out.println(b.show(d)); // "A and D"
}
}
class A {
public String show(D obj) {
return ("A and D");
}
public String show(A obj) {
return ("A and A");
}
}
class B extends A {
public String show(B obj) {
return ("B and B");
}
public String show(A obj) {
return ("B and A");
}
}
class C extends B {
}
class D extends B {
}
this和super区别
this:代表是当前对象或正在创建的对象
super:父类的对象
| this | super | |
|---|---|---|
| 属性 | this.属性;可以访问本类中的属性，父类中的属性 | super.属性；只能访问父类中的属性 |
| 方法 | this.方法();可以访问本类中的方法，父类中的方法。 | super.方法()；只能访问父类中的方法. |
| 构造器 | this(参数)表示调用当类中的其它构造器，this(参数)最多N-1个 | super(参数),表示调用父类中的构造器，构造器中默认是super() |
增强重写父类中的方法
1.在继承中,子类中的方法要和父类中的方法（返回值类型 方法名 参数列表）要一致。
注意：父类方法：public 父类类型 方法名（参数）{}
子类方法：public 父类类型/子类类型 方法名（参数）{}
2.子类中的权限修饰符不能小于父类中的权限修饰符
3.子类中的抛出的异常不能大于父类中抛出的异常。
4.static子类不能重写父类中的方法，static静态;子父类的方法同为static和非static
5.final 修饰方法不能被重写(表示的是最终的方法)
6.abstract 声明方法抽象方法，必须被子类方法重写.
7.native 没有方法体，调C或C++的实现 。
8.synchronized 线程锁和重写无关.
String类(Java.lang包)
重点：常量池存储
public static void main(String[] args) {
String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
//== 地址
//equals比较字符串，比较每个字符
System.out.println(s1==s2); //true
System.out.println(s1==s3); //false
System.out.println(s1.equals(s3)); //true
String s4 ="ab"+"c"; //编译时确定
String s5 ="ab"+ new String("c"); //运行时确定
String s6 ="ab";
String s7 = "c";
String s8 = s6 + s7;
String s9 = (s6 + s7).intern(); // 手动添加常量池函数
System.out.println("=======================");
System.out.println("s4==s1:"+(s4==s1)); //true
System.out.println("s5==s1:"+(s5==s1)); //false
System.out.println("s8==s1:"+(s8==s1)); //false
System.out.println("s8==s1:"+(s9==s1)); //true
}
包装器类
//自动转换
//自动拆箱 包装类型=>基本类型
int i5 = i1;
//自动装箱 基本类型=>包装类型
Integer i4 = 1;
String.valueOf(10); // 基本=》String
包装.parseXxx(“”)； //String=》基本
包装器类 对象 = new 包装器类(值); //基本=》包装
扫一扫
3511
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
