1.构造函数
/*
初始化对象：给对象的属性赋值
1：直接赋值法 不常用（除非是那种固定不变值只有一个的）
- 直接在成员变量的后面赋值
2：类名 对象名 = new 类名(); 不常用 - 对象名.属性名
*3：构造器初始化
*Dog dog = new Dog();
注意：new是java中运算符，代表在堆中开辟一个空间（具体开辟多大空间，由JVM来决定）
Dog(),这是一个方法,方法名和类名一致
3.1：新建一个类：编译器会默认给我们创建一个无参的构造方法
3.2：构造方法是一种特殊的方法，它的功能就是初始化一个对象（给属性赋值）
语法格式：
public 类名(){
方法体…
}
3.3:构造方法既不是void，也没有返回值
3.4:构造方法是通过new来调用的 一new就构造，不new不构造
3.5:构造方法也能重载
3.6:如果程序员手动的提供了构造方法，那么编译器提供的那个无参的构造方法就没有了
3.7:如果成员变量和构造方法的形参重名了，如何解决？
3.7.1:改变形参的名字，不要和成员变量相同
3.7.2:在成员变量的前面加关键字this
public class Dog {
String name;
int age;
String color;
public void eat(){
System.out.println("吃饭");
}
public int sleep(){
return 20;
}
public Dog(){
System.out.println("我是一个无参的构造方法");
}
public Dog(String name,int age,String color){
System.out.println("我是有参的构造方法");
this.name = name;
this.age = age;
this.color = color;
}
public void introduce(){
System.out.println("姓名:"+name+" 年龄："+age+" 颜色:"+color);
}
public static void main(String[] args) {
/*Dog d = new Dog();
Dog d1 = new Dog();
System.out.println(d1.name);
System.out.println(d1.age);
System.out.println(d1.color);*/
//创建一个Dog对象
Dog d = new Dog("旺财", 20, "黄色");
d.introduce();
/* Dog d1 = new Dog("小黑", 3, "黑色");
d1.introduce();*/
//Dog d = new Dog();
}
}
2.传参方法
public class Student {
/*
* 方法传参：
* 1：传递基本类型
* 无法通过方法调用改变变量的值
* 2：传递引用类型
* 可以通过方法调用改变变量的值
* eclipse自动生成构造器
* 快键键：shift+alt+s
*
*/
String name;
int age;
String sex;
public void show1(int age){
age = 200;
System.out.println("show1中的age:"+age);
}
public void show2(Student stu1){
stu1.age = 100;
System.out.println("show2中的age:"+stu1.age);
}
public Student() {
}
public Student(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public static void main(String[] args) {
//1：创建一个学生对象
Student stu = new Student("宝强", 20, "男");
Student stu1 = new Student("马蓉", 20, "女");
stu.show2(stu1);
System.out.println("main中的age:"+stu.age);
/*int age= 100;
stu.show1(age);
System.out.println("main中的age:"+age);*/
}
3.This
/*
* 类的基本组成
* 1：成员属性
* 2：成员方法
* 3：构造方法
*
* 成员方法可以相互调用 ：直接写方法名即可
* 注意：实际上在java中方法都是通过 对象.方法名 调用的
* 如果漆面没有直接写对象名，java会默认是this来调用的
* this关键字的用法
* this:当前对象的引用地址(对于方法调用来说。谁调用我，this就是谁)
* 1：调用方法：this.方法名
* this是一个关键字可以省略不写，所以可以直接调用方法
* 2：调用属性:this.属性名
* 当成员属性和方法的形参同名的时候，this可以放在成员属性的前面，为了区分同名
* 3：调用构造方法：this(参数1，参数2...)
* 注意：
* 3.1 成员方法可以调用成员方法
* 3.2 成员方法不可以调用构造方法
* 3.3 构造方法可以调用成员方法
* 3.4 构造方法可以调用构造方法
*
* 注意：this()只能出现在构造方法的第一句
* 因为构造方法的作用就是给对象初始化，所以this只能出现在构造器的第一行，先让对象的属性初始化，然后在做其他事情
* 注意：this不可以出现在static方法中
* 注意：实际开发中，我们会给一个类至少提供2个构造器
* 一个无参的，一个有参的
*/
public class Student {
String name;
int age;
String sex;
//无参
public Student(){
this("宝");
eat();
System.out.println("我是无参的构造器");
}
//1个参数
public Student(String name){ //宝
this("马",20);
System.out.println("我是1个参数的构造器");
this.name = name;
}
//2个参数
public Student(String name,int age){ //马 20
this("宋",30,"男");
System.out.println("我是2个参数的构造器");
this.name = name;
this.age = age;
}
//3个参数
public Student(String name,int age,String sex){//"宋",30,"男"
System.out.println("我是3个参数的构造器");
this.name = name;
this.age = age;
this.sex = sex;
}
public void eat(){
//Student();
//study();
//System.out.println(this);
//System.out.println("吃饭");
}
public void study(){
sleep();
System.out.println(this);
//System.out.println("学习");
}
public void sleep(){
System.out.println("睡觉");
}
public static void main(String[] args) {
Student stu = new Student();
System.out.println(stu.name);
System.out.println(stu.age);
System.out.println(stu.sex);
//宝 20 男
/*Student stu1 = new Student();
stu1.eat();*/
/*Student stu2 = new Student();
stu2.eat();
System.out.println(stu2);*/
}
}
**this的作用:
this表示的是当前对象本身，
更准确地说，this代表当前对象的一个引用。
普通方法中使用this。
区分类成员属性和方法的形参.
调用当前对象的其他方法（可以省略）
位置：任意
构造方法中使用this。
使用this来调用其它构造方法
位置：必须是第一条语句
this不能用于static方法。（讲完static，大家就知道为什么了！）*
4.Static
/*
* 分析问题
* 先有对象，再有类
* 解决问题
* 先有类，再有对象
*
* static关键字的用法
* 语法格式
* static 数据类型 变量名= 值; 静态
* 数据类型 变量名 = 值 非静态
*
*
* 1：static修饰变量
* 1.1：static 修饰变量，会让变量成为类变量，也是静态变量，这个变量属于当前这个类，和对象没有关系
* 1.2:静态变量是随着JVM第一次把类加载到内存中的时候，就把值赋值好了，比对象要提前，静态变量都有默认值
* 1.3：静态变量属于一个共享的变量，每个对象都可以使用这个变量，静态变量存放的位置是内存中方法区
* 静态变量和非静态变量的区别 ？
* 共同点:
* 1：都是变量
* 2：都有默认值
* 不同点：
* 1：内存位置
* 静态变量：方法区
* 非静态变量:堆
* 2：个数
* 静态变量 ：1个 被所有对象共享
* 非静态变量：多个 每个对象都有各自的1个
* 3：调用形式
* 静态变量: 对象名.变量名 不推荐
* 类名.变量名 推荐
* 非静态变量:对象名.变量名
* 4:加载时机
* 静态变量 :类被第一次加载进内存的时候，空间就分配好了
* 非静态变量:当你new对象的时候，才分配空间
*
* 静态变量和非静态变量的使用场合
* 根据这个变量是否被对象所共享来判断这个变量应该定义成哪种变量
* 注意：局部变量不可以加static关键字
public class Demo {
int a = 1;//成员变量
static int b;//静态类变量
public void eat(){
System.out.println(a);
System.out.println(b);
}
public static void main(String[] args) {
Demo d = new Demo();
System.out.println(d.b);
System.out.println(Demo.b);
//System.out.println(Demo.a);
//System.out.println(a);
}
}
public class Demo3 {
/*
* 静态代码块:static经常用来进行static变量的初始化。
* 当类被第一次加载的时候，首先会加载静态代码块
* 如果这个类被加载多次，那么这个静态代码块，不用多次加载,只需要使用第一次加载好的值即可，可以提高效率
* 语法格式
* static{
* 代码块
* }
* 注意：静态代码块只能初始化静态变量，不能初始化非静态变量
*
* 非静态代码块: 初始化变量值
* 语法格式
* {
* 代码块
* }
* 注意：非静态代码块可以初始化非静态变量以及静态变量
*/
int a;
static int b = 10;
static int c = 20;
static{
b = 10;
c = 20;
//a = 100;
}
{
a = 100;
b = 100;
c= 2000;
}
public static void main(String[] args) {
}
}
5.java语法的执行顺序
public class Demo3 {
/*
* 静态代码块:static经常用来进行static变量的初始化。
* 当类被第一次加载的时候，首先会加载静态代码块
* 如果这个类被加载多次，那么这个静态代码块，不用多次加载,只需要使用第一次加载好的值即可，可以提高效率
* 语法格式
* static{
* 代码块
* }
* 注意：静态代码块只能初始化静态变量，不能初始化非静态变量
*
* 非静态代码块: 初始化变量值
* 语法格式
* {
* 代码块
* }
* 注意：非静态代码块可以初始化非静态变量以及静态变量
*/
int a;
static int b = 10;
static int c = 20;
static{
b = 10;
c = 20;
//a = 100;
}
{
a = 100;
b = 100;
c= 2000;
}
public static void main(String[] args) {
}
}
6.Pack的作用
public class Student {
/*
* package的作用？
* 1：为了解决类之间的重名问题。
* 2：为了便于管理类：合适的类位于合适的包！
* MVC 分层开发
*
* dao:数据访问层 抽象层
* dao.impl:数据访问层的实现包
* servlet：控制层
* service:业务层 抽象层
* service.impl:业务层的的实现包
* util：工具包
* entity：实体包
* filter:过滤器包
*
* 包通常是类的第一句非注释性语句。
* 一个类治只有一个包语句
* 注意：写包的格式
* 域名倒着写+项目名+模块名，并与内部管理类。
* com.sxt.sms.dao
* com.sxt.sms.service
* com.sxt.sms.util
* StudentManagerSystem
* 包的展现方式
* 1：平级
* 2：继承 常用
* 常用包
* java.lang:核心包 可以直接使用，不用导包
* java.awt:图形界面开发包
* java.io:输入输出流包
* java.net:网络编程包
* java.util:工具包，一些常用类的包，例如：日期，数组，集合等等
* com.sxt.day1210.entity:自定义包
*
* 注意：1 除了java.lang包下的类可以直接使用，其他jdk提供的类都得导包
* 2 如果自定义的类处于同一个包，不用导包直接使用
* 3 如果自定义类处于不同的包，需要导包才能使用
*/
public static void main(String[] args) {
Teacher t = new Teacher();
String s = "123";
String.valueOf(true);
Arrays.sort(new int[]{10,20,50});
}
}