package java_mianxiangduixiang;
//TODO 开始面向对象的学习：
//属性不用初始化，因为会根据类型自动初始化默认值。变量在使用前必须要初始化
public class java_01 {
public static void main(String[] args) {
//如果想烹饪一道菜，例如红烧排骨，此时整体来思考问题而不是一个一个的去解决，即面向对象：
//1.先声明类
//2.创建对象
//3.声明属性所谓的属性就是类中的变量
//4.声明方法：
//5.执行方法
Cooking c=new Cooking();
c.foods="排骨";
c.name="红烧排骨";
c.type="红烧";
c.execute();
}
}
class Cooking{
//属性：
String name;//名字
String type;
String foods;
String relish="大料";
void execute(){
System.out.println("准备食材"+foods);
System.out.println("准备佐料"+relish);
System.out.println("开始烹饪");
System.out.println(name+"烹饪完成");
}
}
package java_mianxiangduixiang;
//TODO 方法：参数的使用：
// 注意事项：参数的个数需要匹配。参数的类型需要匹配。当参数的个数不确定但是类型确定的时候，防止一个一个的添加参数更改，
// 可以采用特殊的参数语法声明：可变参数，如果参数中还有其他类型的参数，需要将可变参数放置到最后。
//详细请看word文档中的解释：int和String为什么不同，对于String和User都是引用数据类型为什么不同.
//java中方法参数的传递：对于基本数据类型传递的是值，对于引用数据类型传递的是地址；
public class java_02 {
??? public static void main(String[] args) {
??????? String name1="zhangsan";
??????? String name2="lisi";
??????? //一下三个都不会报错：
??????? sayhello(30);
??????? sayhello(18,name1);
??????? sayhello(90,name1,name2);
??????? int num=10;
??????? System.out.println(num);//发现没有发生变化
??????? String s="abc";
??????? test1(s);
??????? System.out.println(s);//发现没有发生变化
??????? User user=new User();
??????? user.name="张三";
??????? System.out.println(user.name);
??????? test2(user);
??????? System.out.println(user.name);//发生了改变
??? }
??? static void sayhello(int age,String... name){
??????? System.out.println("hello"+age+name);
??? }
??? static void test(int num){
??????? num=num+10;
??? }
??? static void test1(String s){
??????? s="aaa";
??? }
??? static void test2(User user){
??????? user.name="你好";
??? }
}
class User{
??? String name;
}
package java_mianxiangduixiang;
//TODO 静态：static关键字
// 和类强相关的属性称为静态属性,例如定义鸟这个类，鸟都会飞，并且类型都是鸟
// 和类强相关的方法称为静态方法
//静态方法和静态属性就是在其前面添加一个static关键字，可以直接用类名.方法来调用，不需要先创建对象然后再调用
//静态是跟着类的加载而加载的，先有类然后再有对象，因此对象也可以调用静态方法，并且类中的普通方法也可以调用静态方法，但是静态方法不能调用普通方法。
public class java_03 {
public static void main(String[] args) {
//static的基本使用：
System.out.println(Bird.type);
Bird.fly();
Bird b=new Bird();
b.name="小鸡";//此处给静态变量赋值了；
b.body="手";//这里给该对象的body赋值
Bird b1=new Bird();
System.out.println(b1.name);//这里输出的是小鸡，说明如果一个静态属性没有被赋值，一个对象对其赋值之后所有对象对其调用都是这个值。对于普通属性来说，其值还是默认值。
System.out.println(b1.body);//这里输出的是null，String类型变量的默认值
//重要：对于静态属性和静态方法，就算是实例化了一个空对象也可以执行，因为静态属性和方法是跟着类的加载而加载的；
Bird bbb=null;
System.out.println(bbb.type);
//静态代码块：下方Test类中，静态代码块在类的信息加载完成后自动执行，可以完成静态属性的初始化，例如下方调用了test静态方法，说明类的信息已经加载完成；
Test.test();
//创建一个对象，说明类的信息加载完成，即也执行静态代码块,但是前面调用静态方法已经执行过一次，这里就不执行了。
//下方没加static的代码块是专门对于对象创建的时候才会执行（是在构造对象之前执行的；），上方那个调用test静态方法，这里静态方法不会执行,并且这个可以执行多次，创建一个对象执行一次，并不像静态代码块一样只能执行一次；
new Test();
new Test();
}
}
class Bird{
static String type="鸟";
static String name;
String body;
static void fly(){
System.out.println("我会飞");
}
void show(){
fly();
}
}
class Test{
static{
System.out.println("静态代码块执行");
}
static void test(){
System.out.println("静态方法执行");
}
{
System.out.println("代码块执行");
}
}
package java_mianxiangduixiang;
//TODO package：
//一个类可以没有包，但是如果有的话最多只能写一个
//包名为了区分类名，一般都是小写
//有时会遇到同一个类但是不同包里，就像Date类，两个包中都有Date类，因此需要写全类的全名（包名+类名）
//TODO import:
//如果需要多次导入这个包中的类，可以直接用*：如下
//TODO 构建对象：如果一个类中没有任何构造方法，那么JVM会自动添加一个公共的，无参的构造方法，方便对象的调用；
//例如：User use=new User();为什么要加括号，其实就是调用了构造方法。
//构造方法基本语法：类名(){}；1.构造方法也是方法，但是没有void关键字；2.方法名和类名完全相同；
// 3.如果类中没有构造方法，那么java虚拟机JVM会提供默认的构造方法；4.如果类中有构造方法那么JVM不会提供默认的构造方法；
// 5.构造方法也是方法因此可以传递参数；但是一般传递参数的目的是用于对象属性的赋值；6.构造方法是在new对象的时候调用的,new一个对象执行一次；
public class java_04 {
public static void main(String[] args) {
User1 one=new User1("zhangsan");
System.out.println(one.username);
User1 two=new User1("lisi");
}
}
class User1{
String username;
//构造方法如下：主要作用就是为username属性赋值；
User1(String name){
username=name;
System.out.println("hello");
}
}
package java_mianxiangduixiang;
//TODO 继承 extends
//面向对象中有三个非常重要的特性：封装 继承 多态
//对于继承：类存在父子关系，子类可以直接获取到父类的成员属性和成员方法；
//java中一个类只能有一个父类，但是一个类可以有多个子类；
public class java_05 {
public static void main(String[] args) {
Child one=new Child();
System.out.println(one.name);
one.test();
}
}
class Parent{
String name="zhangsan";
void test(){
System.out.println("hello"+" "+name);
}
}
class Child extends Parent{
}
package java_mianxiangduixiang;
//TODO 如果父类和子类有相同的属性，那么可以采用特殊的关键字进行区分：super this
public class java_06 {
public static void main(String[] args) {
Child1 child=new Child1();
child.test();//虽然继承了父类，获得了父类的name属性，但是输出的是自己新定义的属性值；因此想要区分开就得用super和this
child.test1();
}
}
class Father{
String name="zhangsan";
}
class Child1 extends Father{
String name="lisi";
void test(){
System.out.println(name);
}
void test1(){
System.out.println(super.name);
System.out.println(this.name);
}
}
package java_mianxiangduixiang;
public class java_07 {
public static void main(String[] args) {
//首先对于构造方法，每次new一个对象后就会执行一次，从以下可以知道每次创建一个子类对象先要调用父类的构造函数然后再创建子类对象
People1 one =new People1();
People1 two=new People1();
People1 three=new People1();
System.out.println(one.name);
}
}
//其实每次子类创建对象都会默认调用父类的构造方法，super()，JVM会自动调用,不用自己写，
// 但是当父类的构造方法有参数而子类没有时，这时就会报错，因为先调用父类的构造方法然后才会调用子类的构造方法，
// 此时父类需要传参但是没有传进参数去所以会报错;实质上是子类构造方法中有一个super();不用自己写，此时需要在super（”传进参数“）就可以
class User2{
String name;
User2(String na){
name=na;
System.out.println("父类对象创建！");
}
}
class People1 extends User2{
People1(){
super("zhangsan");//这样就不会报错了，如果父类构造方法中没有参数可以不用写super（），但是有参数了必须得传参了
System.out.println("子类对象创建！");
}
}
package java_mianxiangduixiang;
//多态：多态就是一个对象在不同场景下表现出来的不同状态和形态；
//多态语法其实就是对对象的使用场景进行了约束；
public class java_08 {
public static void main(String[] args) {
Person one=new boy();
one.test1();
//one.test();会报错，执行boy类中的方法会报错，进行了约束；
Person two=new girl();
two.test1();
//two.test();会报错，执行girl类中的方法会报错,这就是进行了约束
}
}
class Person{
void test1(){
System.out.println("父类方法");
}
}
class boy extends Person{
void test(){
System.out.println("boy");
}
}
class girl extends Person{
void test(){
System.out.println("girl");
}
}