目录
构造方法：
- 用于构建对象，在 new 对象的时候调用执行
- 如果一个类中没有任何构造方法，JVM 会自动添加一个 公共的、无参的 构造方法，方便对象调用
- 类名 () { xxx }
- 构造方法也是方法，但是没有 void 关键字
- 方法和类名完全相同
- 构造方法也可以传递参数，一般用于对象属性的赋值
- 代码块 比构造方法先执行
public class Java11_Object_Instance {
public static void main(String[] args) {
// TODO 面向对象 - 构建对象
// 构造方法：专门用于构建对象
// 如果一个类中没有任何的构造方法，那么JVM会自动添加一个公共的，无参的构造方法，方便对象的调用
// TODO : 基本语法： 类名（）{}
// 1. 构造方法也是方法，但是没有void关键字。
// 2. 方法名和类名完全 相同
// 3. 如果类中没有构造方法，那么JVM会提供默认的构造方法
// 4. 如果类中有构造方法，那么JVM不会提供默认的构造方法
// 5. 构造方法也是方法，所以也可以传递参数，但是一般传递参数的目的是用于对象属性的赋值
//System.out.println("before...");
User11 user = new User11("zhangsan");
//System.out.println("after...");
user.test();
System.out.println(user.username);
// 代码块，是在构造对象之前执行的
}
}
class User11 {
String username;
{
System.out.println("代码块1");
}
User11(String name) {
username = name;
System.out.println("user...");
}
{
System.out.println("代码块2");
}
void test() {
System.out.println("test...");
}
{
System.out.println("代码块3");
}
}
继承：
面向对象编程 3 个重要特征：继承、封装、多态
- 类存在父子关系，子类可以直接获取父类的成员属性和成员方法，提高开发效率，有利于代码维护升级
- 类的继承只能是单继承，一个类只能有一个父类，但一个父类可以有多个子类
- 子类 extends 父类
- 如果父类和子类含有相同的属性，那么可以采用特殊的关键字进行区分：super、this，都表示对象
- 构造方法：
- 父类对象是在子类对象创建前创建完成，创建子类对象前，会调用父类的构造方法完成父类的创建
- 默认情况下，子类对象构建时，会默认调用父类的构造方法完成父类对象的创建。使用的是super的方式，只不过JVM自动完成(无参构造方法)
- 如果父类提供构造方法，那么JVM不会提供默认的构造方法，那么子类应该显示调用super方法构建父类对象。
- new 只会构建一个对象，在内存中只会开辟一块空间存储创建的对象
public class java11_object_extends { public static void main(String[] args) { Child c =new Child(); c.test(); } } class Parent{ String name="dongzhuo"; void test(){ System.out.println("名字:"+name); } } class Child extends Parent{ }public class Java12_Object_Extends_1 { public static void main(String[] args) { // TODO 面向对象 - Extends - 继承 // 如果父类和子类含有相同的属性，那么可以采用特殊的关键字进行区分 // super & this. Child1 c = new Child1(); //System.out.println(c.name); c.test(); } } class Parent1 { String name = "zhangsan"; } class Child1 extends Parent1 { String name = "lisi"; void test() { System.out.println(super.name);//父类的name System.out.println(this.name);//子类的name System.out.println(name); } }构造方法的继承
public class Java12_Object_Extends_2 { public static void main(String[] args) { // TODO 面向对象 - Extends - 继承 // 构造方法 // 父类对象是在子类对象创建前创建完成，创建子类对象前，会调用父类的构造方法完成父类的创建 // 默认情况下，子类对象构建时，会默认调用父类的构造方法完成父类对象的创建。使用的是super的方式，只不过JVM自动完成 // 如果父类提供构造方法，那么JVM不会提供默认的构造方法，那么子类应该显示调用super方法构建父类对象。 Child2 c1 = new Child2(); Child2 c2 = new Child2(); Child2 c3 = new Child2(); } } class Parent2 { String username; Parent2 (String name) { username = name; System.out.println("parent..."); } } class Child2 extends Parent2 { Child2() { super("zhangsan"); System.out.println("child..."); } }多态：
- 所谓的多态，其实就是一个对象在不同场景下表现出来的不同状态和形态
- 多态语法其实就是对对象的使用场景进行了约束
- 一个对象可以使用的功能取决于引用变量的类型
- 当 使用父类声明、创建子类对象的时候，子类的方法不可用（父类和子类方法重名时可以用子类的方法）
-
public class Java13_Object { public static void main(String[] args) { // TODO 面向对象 - 多态 // 所谓的多态，其实就是一个对象在不同场景下表现出来的不同状态和形态 // 多态语法其实就是对对象的使用场景进行了约束 // 一个对象可以使用的功能取决于引用变量的类型 Person p = new Person(); p.testPerson(); Person p1 = new Boy(); p1.testPerson(); //p1.testBoy(); Person p2 = new Girl(); p2.testPerson(); //p2.testGirl(); Boy boy = new Boy(); boy.testBoy(); Girl girl = new Girl(); girl.testGirl(); } } class Person { void testPerson() { System.out.println("test person..."); } } class Boy extends Person { void testBoy() { System.out.println("test boy..."); } } class Girl extends Person { void testGirl() { System.out.println("test girl..."); } }
方法重载：
- 一个类中不能重复声明相同的方法/属性
- 这里相同的方法是指 方法名、参数列表相同，和返回值类型无关
- **重载：**如果方法名相同，但参数列表（个数，顺序，类型）不相同，会认为是不同的方法，只不过名称一样
- 构造方法也存在方法重载，如：new User(xxx)
- 如果在一个构造方法中,想要调用其他的构造方法，那么需要使用特殊的关键字：this
- 基本数据类型在匹配方法时，可以在数值不变的情况下扩大数据精度
- byte类型无法和char类型做转换，char没有负数，但byte有负数
普通方法重载和构造方法重载
public class Java14_Object {
public static void main(String[] args) {
// TODO 面向对象
// 一个类中，不能重复声明的相同的方法，也不能声明相同的属性
// 这里相同的方法指的是方法名，参数列表相同,和返回值类型无关
// 如果方法名相同，但是参数列表（个数，顺序，类型）不相同，会认为是不同的方法，只不过名称一样
// 这个操作在Java称之方法的重载
// 构造方法也存在方法的重载
User14 user = new User14("zhangsan");
user.login(1111);
user.login("123123");
user.login("zhangsan", "123123");
}
}
class User14 {
User14() {
System.out.println("user...");
}
User14(String name) {
System.out.println("user..." + name);
}
void login( String account, String password ) {
System.out.println("账号，密码登录");
}
void login(int tel) {
System.out.println("手机验证码登录");
}
void login(String wx) {
System.out.println("微信，支付宝登录");
}
}
构造方法重载调用另外构造方法
public class Java14_Object_1 {
public static void main(String[] args) {
// TODO 面向对象
// 如果在一个构造方法中。想要调用其他的构造方法，那么需要使用特殊的关键字：this
User141 user1 = new User141();
//User141 user2 = new User141("zhangsan");
//User141 user3 = new User141("zhangsan", "男");
}
}
class User141 {
User141() {
this("zhangsan");
}
User141( String name ) {
this(name, "男");
}
User141( String name, String sex ) {
System.out.println(name + "," + sex);
}
}
基本数据类型在匹配方法时，可以在数值不变的情况下扩大数据精度
public class Java14_Object_2 {
public static void main(String[] args) {
// TODO 面向对象
byte b = 10;
// test(b); bbb
// int => iii
// byte => 8
// short => 16
// char => 16
// int => 32
// 基本数据类型在匹配方法时，可以在数值不变的情况下，扩大数据的精度
// byte类型无法和char类型做转换，char没有负数，但是byte存在负数
// test(b);
}
// static void test( byte b ) {
// System.out.println("bbb");
// }
// static void test( short s ) {
// System.out.println("sss");
// }
static void test( char c ) {
System.out.println("ccc");
}
// static void test( int i ) {
// System.out.println("iii");
// }
}
方法重写
- 父类对象的方法主要体现通用性，无法在特殊场合下使用，如果子类对象需要在特殊场合下使用，就需要重写方法的逻辑
- 重写并不意味着父类的方法被覆盖，只是当前场合不适用，使用super还是可以访问
- **重写要求：**子类方法和父类方法方法名相同、返回值类型相同、参数列表相同
- 构造方法不能重写
- 一个对象方法的具体使用（直接、间接）是需要看具体对象的
- 一个对象属性的具体使用不需要看具体对象，属性在哪里声明在哪里使用
注：子类没有找父类（就那么简单）
public class java18_fulei {
public static void main(String[] args) {
// Parent18 p1=new Parent18();
// p1.test();
Parent18 p2=new Child18();
p2.test();
}
}
class Parent18{
int i=10;
void test(){
System.out.println(i+10);
}
}
class Child18 extends Parent18{
// int i=11;
void test(){
System.out.println(i+20);
}
}
public class Java15_Object {
public static void main(String[] args) {
// TODO 面向对象 - 重写
// 方法的重写：父类对象的方法其实主要体现通用性，无法在特殊的场合下使用
// 如果子类对象需要在特殊的场合下使用，那么就需要重写方法的逻辑，这个操作在Java中称之为方法的重写
// 这里的重写，并不意味着父类的方法被覆盖掉，只是在当前场合不使用。如果使用super关键字还是可以访问
// 方法的重写要求，子类的方法和父类的方法，方法名相同，返回值类型相同，参数列表要相同
Child15 child = new Child15();
child.test();
}
}
class Parent15 {
String name = "zhangsan";
void test() {
System.out.println("parent test...");
}
}
class Child15 extends Parent15 {
String name = "lisi";
@Override
void test() {
// System.out.println(this.name);
// System.out.println(super.name);
super.test();
System.out.println("child test...");
}
}
递归：
-
方法调用自身（阶乘等）
-
方法要有跳出的逻辑，注意 StackOverflowError 异常
-
调用自身时，传递的参数要有规律
public class java20_jieceng {
public static void main(String[] args) {
int result=computed(5);
System.out.println(result);
}
public static int computed(int num) {
if (num==1){
return 1;
}else{
return num*computed(num-1);
}
}
}访问权限：
public : 公共的，访问权限修饰符
Java的源码中，公共类只能有一个，而且必须和源码文件名相同
main方法：main方法是由JVM调用的，JVM调用时应该可以任意调用，而不用考虑权限问题。
Java中的访问权限主要分为4种：
- private : 私有的, 同一个类中可以使用
- (default) : 默认权限, 当不设定任何权限时，JVM会默认提供权限，包(路径)权限，子类的包不可以访问
- protected : 受保护的权限, 子类可以访问
- public : 公共的, 任意使用
所谓的访问权限，其实就是访问属性，方法的权力和限制。
public class Java17_Object_Access_1 {
public static void main(String[] args) {
// TODO 面向对象 - 访问权限
Person17 person = new Person17();
// private : 同类
// default ： 同类，同包（路径）
// protected：同类，同包（路径），子类
// public ：公共的
// 所谓的访问权限，其实就是访问属性，方法的权力和限制。
// 谁访问？Java17_Object_Access_1 -> super -> java.lang.Object
// 访问谁的？Person17 -> super -> java.lang.Object(clone)
// person.clone();
}
}
class Person17 {
void test() throws Exception {
clone();
}
}
内部类：
-
Java不允许外部类使用private, protected修饰
/所谓的外部类，就是在源码中直接声明的类
所谓的内部类，就是类中声明的类 -
内部类就当成外部类的属性使用即可
-
因为内部类可以看作外部类的属性，所以需要构建外部类对象才可以使用
public class Java18_Object {
public static void main(String[] args) {
// TODO 面向对象 - 外部类 - 内部类
// Java不允许外部类使用private, protected修饰
// 所谓的外部类，就是在源码中直接声明的类
// 所谓的内部类，就是类中声明的类
// 内部类就当成外部类的属性使用即可
// 因为内部类可以看作外部类的属性，所以需要构建外部类对象才可以使用
OuterClass outer = new OuterClass();
OuterClass.InnerClass innerClass = outer.new InnerClass();
}
}
class OuterClass {
public class InnerClass {
}
}
215
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
