面向对象编程
package com.oop.demo01;
import java.io.IOException;
//Demo01 类
public class Demo01 {
//main 方法
public static void main(String[] args) {
}
/*
修饰符 返回值类型 方法名（...）｛
//方法体
return 返回值；
｝
*/
public String sayHello(){
return"hello,word";
}
//return 结束方法，返回一个结果！
public void print(){
return;
}
public int max(int a,int b){
return a>b?a:b;//三元运算符
}
//数组下标越界异常。。。。。。
public void readFile(String file)throws IOException{
//异常抛出
}
}
package com.oop.demo01;
//静态方法 static
//非静态方法
public class Demo02 {
public static void main(String[] args) {
//实例化这个类new
//对象类型 对象名 = 对象值；（当另一个方法是非静态方法时需要先用new实例化）
Student student = new Student();
student.say();
}
public void a(){
}
}
------------------------------------新建包调用
package com.oop.demo01;
//学生类
public class Student {
public void say(){
System.out.println("学生说话了");
}
}
package com.oop.demo01;
public class Demo03 {
public static void main(String[] args) {
// int add =new Demo03().add(1,2); 非静态变量的时候用这个调用，不用new实例化
//实际参数和形式参数的类型要相对应
int add = Demo03.add(1, 2);//括号内为实际参数
System.out.println(add);
}
public static int add(int a,int b){ //括号内为形式参数
return a+b;
}
}
package com.oop.demo01;
public class Demo04 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);//1
Demo04.change(a);
System.out.println(a);//1
}
//因为有void 所以返回值为空，所以输出还是为1
public static void change(int a){
a = 10;
}
}
package com.oop.demo01;
//引用传递：对象 本质还是值传递
public class Demo05 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);//null
Demo05.change(person);
System.out.println(person.name);//朱
}
public static void change(Person person) {
//person是一个对象：指向的----->Person person = new Person(); 这是一个具体的人，可以改变属性
person.name = "朱";
}
//定义了一个Person类，有一个属性，name
static class Person {
String name;//numll
}
}
package com.oop.demo02;
public class Application {
public static void main(String[] args) {
//类：抽象的，实例化的
//类实例化后会返回一个自己的对象！
//student对象就是一个Student类的具体实例！
Student xm = new Student();
Student xh = new Student();
xm.name = "小明";
xm.age = 10;
System.out.println(xm.name);
System.out.println(xm.age);
xh.name = "小红";
xh.age = 15 ;
System.out.println(xh.name);
System.out.println(xh.age);
}
}
---------------------------------调用
package com.oop.demo02;
//学生类
public class Student {
//属性：字段
String name;//num
int age;//0
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
构造方法
package com.oop.demo02;
//alt+insert 快速构造有参无参
public class Person {
//一个类即使什么都不写，它也会存在一个方法
//显示的定义构造器
String name;
int age;
//实例化初始值
//1.使用new关键字，本质是在调用构造器
//2.用来初始化值
public Person(){
this.name="qingjiang";
}
//有参构造,即有参数。一旦定义了有参构造，无参就必须显示定义
public Person(String name){
this.name = name ;
}
}
/*
public static void main(String[] args) {
//实例化一个对象
Person person = new Person("qingjiang");
System.out.println(person.name);
}
构造器：
1.和类名相同
2.没有返回值
作用:
1.new 本质就是在调用构造方法
2.初始化对象的值
注意点：
1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
this. 当前类
*/
创建对象内存分析
1.类与对线
类是一个模板：抽象，对象是一个具体的实例
2.方法
定义、调用！
3.对应的引用
引用的类型：基本类型（八大）
对象是通过引用来操作的：栈----->椎
4.属性：字段Field成员变量
默认初始化：
数字： 0 0.0
char：u0000
boolean:false
引用：null
修饰符 属性类型 属性名 = 属性值！
5.对象的创建和使用
必须使用new 关键字创造对象，构造器 Person kuangshen = new Person（）；
对象的属性 kuangsheng.name
对象的方法：kuangshen.sleep（）
6.****类
静态的属性 属性
动态的行为 方法
封装、继承、多态
package com.oop.demo03;
public class Pet {
public String name;
public int age;
//无参构造(隐藏的)
public void shout(){
System.out.println("叫了一声");
}
}
/*
package com.oop.demo02;
import com.oop.demo03.Pet;
//一个项目只能有一个main方法
public class Application02 {
public static void main(String[] args) {
Pet dog = new Pet();
dog.name = "旺财";
dog.age = 3;
dog.shout();
System.out.println(dog.name);
System.out.println(dog.age);
}
}
*/